@ikas/storefront-api 4.0.0-alpha.10

package/src/__api/models/StorefrontOrder.ts

@@ -0,0 +1,116 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import {
+  CancelledReasonEnum,
+  OrderPackageStatusEnum,
+  OrderPaymentStatusEnum,
+  ShippingMethodEnum,
+  OrderStatusEnum,
+} from "../types";
+import { OrderAddressData } from "./OrderAddress";
+import { OrderCurrencyRateData } from "./OrderCurrencyRate";
+import { OrderCustomerData } from "./OrderCustomer";
+import { OrderGiftPackageLineData } from "./OrderGiftPackageLine";
+import { InvoiceData } from "./Invoice";
+import { OrderAdjustmentData } from "./OrderAdjustment";
+import { OrderLineItemData } from "./OrderLineItem";
+import { OrderPackageData } from "./OrderPackage";
+import { OrderPaymentMethodData } from "./OrderPaymentMethod";
+import { OrderShippingLineData } from "./OrderShippingLine";
+import { OrderTaxLineData } from "./OrderTaxLine";
+
+export class StorefrontOrderData extends BaseModelData {
+  billingAddress: OrderAddressData | null;
+  cancelReason: CancelledReasonEnum | null;
+  cancelledAt: any | null;
+  currencyCode: string;
+  currencyRates: OrderCurrencyRateData[];
+  customer: OrderCustomerData | null;
+  customerId: string | null;
+  giftPackageLines: OrderGiftPackageLineData[] | null;
+  giftPackageNote: string | null;
+  invoices: InvoiceData[] | null;
+  isGiftPackage: boolean | null;
+  merchantId: string;
+  note: string | null;
+  orderAdjustments: OrderAdjustmentData[] | null;
+  orderLineItems: OrderLineItemData[];
+  orderNumber: string | null;
+  orderPackageStatus: OrderPackageStatusEnum | null;
+  orderPackages: OrderPackageData[] | null;
+  orderPaymentStatus: OrderPaymentStatusEnum | null;
+  orderTagIds: string[] | null;
+  orderedAt: any | null;
+  paymentMethods: OrderPaymentMethodData[] | null;
+  shippingAddress: OrderAddressData | null;
+  shippingLines: OrderShippingLineData[] | null;
+  shippingMethod: ShippingMethodEnum;
+  status: OrderStatusEnum;
+  taxLines: OrderTaxLineData[] | null;
+  totalFinalPrice: number;
+  totalPrice: number;
+
+  constructor(data: Partial<StorefrontOrderData> = {}) {
+    super(data);
+
+    this.billingAddress = data.billingAddress
+      ? new OrderAddressData(data.billingAddress)
+      : null;
+    this.cancelReason = data.cancelReason || null;
+    this.cancelledAt = data.cancelledAt || null;
+    this.currencyCode = data.currencyCode || "";
+    this.currencyRates = data.currencyRates
+      ? data.currencyRates.map((o) => new OrderCurrencyRateData(o))
+      : [];
+    this.customer = data.customer ? new OrderCustomerData(data.customer) : null;
+    this.customerId = data.customerId || null;
+    this.giftPackageLines = data.giftPackageLines
+      ? data.giftPackageLines.map((o) => new OrderGiftPackageLineData(o))
+      : null;
+    this.giftPackageNote = data.giftPackageNote || null;
+    this.invoices = data.invoices
+      ? data.invoices.map((i) => new InvoiceData(i))
+      : null;
+    this.isGiftPackage =
+      data.isGiftPackage !== undefined && data.isGiftPackage !== null
+        ? data.isGiftPackage
+        : null;
+    this.merchantId = data.merchantId || "";
+    this.note = data.note || null;
+    this.orderAdjustments = data.orderAdjustments
+      ? data.orderAdjustments.map((o) => new OrderAdjustmentData(o))
+      : null;
+    this.orderLineItems = data.orderLineItems
+      ? data.orderLineItems.map((o) => new OrderLineItemData(o))
+      : [];
+    this.orderNumber = data.orderNumber || null;
+    this.orderPackageStatus = data.orderPackageStatus || null;
+    this.orderPackages = data.orderPackages
+      ? data.orderPackages.map((o) => new OrderPackageData(o))
+      : null;
+    this.orderPaymentStatus = data.orderPaymentStatus || null;
+    this.orderTagIds = data.orderTagIds || null;
+    this.orderedAt = data.orderedAt || null;
+    this.paymentMethods = data.paymentMethods
+      ? data.paymentMethods.map((o) => new OrderPaymentMethodData(o))
+      : null;
+    this.shippingAddress = data.shippingAddress
+      ? new OrderAddressData(data.shippingAddress)
+      : null;
+    this.shippingLines = data.shippingLines
+      ? data.shippingLines.map((o) => new OrderShippingLineData(o))
+      : null;
+    this.shippingMethod =
+      data.shippingMethod || ShippingMethodEnum.CLICK_AND_COLLECT;
+    this.status = data.status || OrderStatusEnum.CANCELLED;
+    this.taxLines = data.taxLines
+      ? data.taxLines.map((o) => new OrderTaxLineData(o))
+      : null;
+    this.totalFinalPrice = data.totalFinalPrice || 0;
+    this.totalPrice = data.totalPrice || 0;
+  }
+}
+
+export class StorefrontOrder extends StorefrontOrderData {}
+export type PartialStorefrontOrder = Partial<StorefrontOrder>;
+export type ReadOnlyStorefrontOrder = DeepReadonly<StorefrontOrder>;

package/src/__api/models/StorefrontRouting.ts

@@ -0,0 +1,29 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { StorefrontDynamicCurrencySettingsData } from "./StorefrontDynamicCurrencySettings";
+
+export class StorefrontRoutingData extends BaseModelData {
+  countryCodes: string[] | null;
+  domain: string | null;
+  dynamicCurrencySettings: StorefrontDynamicCurrencySettingsData | null;
+  locale: string;
+  path: string | null;
+  priceListId: string | null;
+
+  constructor(data: Partial<StorefrontRoutingData> = {}) {
+    super(data);
+
+    this.countryCodes = data.countryCodes || null;
+    this.domain = data.domain || null;
+    this.dynamicCurrencySettings = data.dynamicCurrencySettings
+      ? new StorefrontDynamicCurrencySettingsData(data.dynamicCurrencySettings)
+      : null;
+    this.locale = data.locale || "";
+    this.path = data.path || null;
+    this.priceListId = data.priceListId || null;
+  }
+}
+
+export class StorefrontRouting extends StorefrontRoutingData {}
+export type PartialStorefrontRouting = Partial<StorefrontRouting>;
+export type ReadOnlyStorefrontRouting = DeepReadonly<StorefrontRouting>;

package/src/__api/models/StorefrontTheme.ts

@@ -0,0 +1,25 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { StorefrontThemeStatus } from "../types";
+
+export class StorefrontThemeData extends BaseModelData {
+  isMainTheme: boolean;
+  name: string;
+  status: StorefrontThemeStatus;
+  themeId: string;
+  themeVersionId: string;
+
+  constructor(data: Partial<StorefrontThemeData> = {}) {
+    super(data);
+
+    this.isMainTheme = data.isMainTheme || false;
+    this.name = data.name || "";
+    this.status = data.status || StorefrontThemeStatus.FAILED;
+    this.themeId = data.themeId || "";
+    this.themeVersionId = data.themeVersionId || "";
+  }
+}
+
+export class StorefrontTheme extends StorefrontThemeData {}
+export type PartialStorefrontTheme = Partial<StorefrontTheme>;
+export type ReadOnlyStorefrontTheme = DeepReadonly<StorefrontTheme>;

package/src/__api/models/StorefrontTransaction.ts

@@ -0,0 +1,53 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import {
+  PaymentMethodEnum,
+  TransactionStatusEnum,
+  TransactionTypeEnum,
+} from "../types";
+import { TransactionErrorData } from "./TransactionError";
+import { TransactionPaymentMethodDetailData } from "./TransactionPaymentMethodDetail";
+
+export class StorefrontTransactionData extends BaseModelData {
+  amount: number;
+  checkoutId: string | null;
+  currencyCode: string;
+  customerId: string | null;
+  error: TransactionErrorData | null;
+  orderId: string | null;
+  paymentGatewayCode: string | null;
+  paymentGatewayId: string;
+  paymentGatewayName: string;
+  paymentMethod: PaymentMethodEnum | null;
+  paymentMethodDetail: TransactionPaymentMethodDetailData | null;
+  processedAt: any | null;
+  refundReason: string | null;
+  status: TransactionStatusEnum;
+  type: TransactionTypeEnum;
+
+  constructor(data: Partial<StorefrontTransactionData> = {}) {
+    super(data);
+
+    this.amount = data.amount || 0;
+    this.checkoutId = data.checkoutId || null;
+    this.currencyCode = data.currencyCode || "";
+    this.customerId = data.customerId || null;
+    this.error = data.error ? new TransactionErrorData(data.error) : null;
+    this.orderId = data.orderId || null;
+    this.paymentGatewayCode = data.paymentGatewayCode || null;
+    this.paymentGatewayId = data.paymentGatewayId || "";
+    this.paymentGatewayName = data.paymentGatewayName || "";
+    this.paymentMethod = data.paymentMethod || null;
+    this.paymentMethodDetail = data.paymentMethodDetail
+      ? new TransactionPaymentMethodDetailData(data.paymentMethodDetail)
+      : null;
+    this.processedAt = data.processedAt || null;
+    this.refundReason = data.refundReason || null;
+    this.status = data.status || TransactionStatusEnum.AUTHORIZED;
+    this.type = data.type || TransactionTypeEnum.REFUND;
+  }
+}
+
+export class StorefrontTransaction extends StorefrontTransactionData {}
+export type PartialStorefrontTransaction = Partial<StorefrontTransaction>;
+export type ReadOnlyStorefrontTransaction = DeepReadonly<StorefrontTransaction>;

package/src/__api/models/StringFilterInput.ts

@@ -0,0 +1,21 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class StringFilterInputData {
+  eq: string | null;
+  in: string[] | null;
+  like: string | null;
+  ne: string | null;
+  nin: string[] | null;
+
+  constructor(data: Partial<StringFilterInputData> = {}) {
+    this.eq = data.eq || null;
+    this.in = data.in || null;
+    this.like = data.like || null;
+    this.ne = data.ne || null;
+    this.nin = data.nin || null;
+  }
+}
+
+export class StringFilterInput extends StringFilterInputData {}
+export type PartialStringFilterInput = Partial<StringFilterInput>;
+export type ReadOnlyStringFilterInput = DeepReadonly<StringFilterInput>;

package/src/__api/models/Town.ts

@@ -0,0 +1,21 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+
+export class TownData extends BaseModelData {
+  districtId: string;
+  name: string;
+  order: number | null;
+
+  constructor(data: Partial<TownData> = {}) {
+    super(data);
+
+    this.districtId = data.districtId || "";
+    this.name = data.name || "";
+    this.order =
+      data.order !== undefined && data.order !== null ? data.order : null;
+  }
+}
+
+export class Town extends TownData {}
+export type PartialTown = Partial<Town>;
+export type ReadOnlyTown = DeepReadonly<Town>;

package/src/__api/models/TrackingInfo.ts

@@ -0,0 +1,24 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class TrackingInfoData {
+  barcode: string | null;
+  cargoCompany: string | null;
+  isSendNotification: boolean | null;
+  trackingLink: string | null;
+  trackingNumber: string | null;
+
+  constructor(data: Partial<TrackingInfoData> = {}) {
+    this.barcode = data.barcode || null;
+    this.cargoCompany = data.cargoCompany || null;
+    this.isSendNotification =
+      data.isSendNotification !== undefined && data.isSendNotification !== null
+        ? data.isSendNotification
+        : null;
+    this.trackingLink = data.trackingLink || null;
+    this.trackingNumber = data.trackingNumber || null;
+  }
+}
+
+export class TrackingInfo extends TrackingInfoData {}
+export type PartialTrackingInfo = Partial<TrackingInfo>;
+export type ReadOnlyTrackingInfo = DeepReadonly<TrackingInfo>;

package/src/__api/models/TransactionError.ts

@@ -0,0 +1,17 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class TransactionErrorData {
+  code: string | null;
+  declineCode: string | null;
+  message: string | null;
+
+  constructor(data: Partial<TransactionErrorData> = {}) {
+    this.code = data.code || null;
+    this.declineCode = data.declineCode || null;
+    this.message = data.message || null;
+  }
+}
+
+export class TransactionError extends TransactionErrorData {}
+export type PartialTransactionError = Partial<TransactionError>;
+export type ReadOnlyTransactionError = DeepReadonly<TransactionError>;

package/src/__api/models/TransactionInstallmentPrice.ts

@@ -0,0 +1,36 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class TransactionInstallmentPriceData {
+  installmentCount: number | null;
+  installmentPrice: number | null;
+  originalRate: number | null;
+  rate: number | null;
+  totalPrice: number | null;
+
+  constructor(data: Partial<TransactionInstallmentPriceData> = {}) {
+    this.installmentCount =
+      data.installmentCount !== undefined && data.installmentCount !== null
+        ? data.installmentCount
+        : null;
+    this.installmentPrice =
+      data.installmentPrice !== undefined && data.installmentPrice !== null
+        ? data.installmentPrice
+        : null;
+    this.originalRate =
+      data.originalRate !== undefined && data.originalRate !== null
+        ? data.originalRate
+        : null;
+    this.rate =
+      data.rate !== undefined && data.rate !== null ? data.rate : null;
+    this.totalPrice =
+      data.totalPrice !== undefined && data.totalPrice !== null
+        ? data.totalPrice
+        : null;
+  }
+}
+
+export class TransactionInstallmentPrice extends TransactionInstallmentPriceData {}
+export type PartialTransactionInstallmentPrice =
+  Partial<TransactionInstallmentPrice>;
+export type ReadOnlyTransactionInstallmentPrice =
+  DeepReadonly<TransactionInstallmentPrice>;

package/src/__api/models/TransactionPaymentMethodDetail.ts

@@ -0,0 +1,39 @@
+import { DeepReadonly } from "ts-essentials";
+import {
+  TransactionCardAssociationEnum,
+  TransactionCardTypeEnum,
+} from "../types";
+import { TransactionInstallmentPriceData } from "./TransactionInstallmentPrice";
+
+export class TransactionPaymentMethodDetailData {
+  bankName: string | null;
+  binNumber: string;
+  cardAssociation: TransactionCardAssociationEnum | null;
+  cardFamily: string | null;
+  cardType: TransactionCardTypeEnum | null;
+  installment: TransactionInstallmentPriceData | null;
+  lastFourDigits: string;
+  threeDSecure: boolean | null;
+
+  constructor(data: Partial<TransactionPaymentMethodDetailData> = {}) {
+    this.bankName = data.bankName || null;
+    this.binNumber = data.binNumber || "";
+    this.cardAssociation = data.cardAssociation || null;
+    this.cardFamily = data.cardFamily || null;
+    this.cardType = data.cardType || null;
+    this.installment = data.installment
+      ? new TransactionInstallmentPriceData(data.installment)
+      : null;
+    this.lastFourDigits = data.lastFourDigits || "";
+    this.threeDSecure =
+      data.threeDSecure !== undefined && data.threeDSecure !== null
+        ? data.threeDSecure
+        : null;
+  }
+}
+
+export class TransactionPaymentMethodDetail extends TransactionPaymentMethodDetailData {}
+export type PartialTransactionPaymentMethodDetail =
+  Partial<TransactionPaymentMethodDetail>;
+export type ReadOnlyTransactionPaymentMethodDetail =
+  DeepReadonly<TransactionPaymentMethodDetail>;

package/src/__api/models/TransactionResponse.ts

@@ -0,0 +1,26 @@
+import { DeepReadonly } from "ts-essentials";
+import { TransactionStatusEnum } from "../types";
+import { TransactionErrorData } from "./TransactionError";
+
+export class TransactionResponseData {
+  error: TransactionErrorData | null;
+  orderId: string | null;
+  orderNumber: string | null;
+  returnSlug: string | null;
+  transactionId: string | null;
+  transactionStatus: TransactionStatusEnum;
+
+  constructor(data: Partial<TransactionResponseData> = {}) {
+    this.error = data.error ? new TransactionErrorData(data.error) : null;
+    this.orderId = data.orderId || null;
+    this.orderNumber = data.orderNumber || null;
+    this.returnSlug = data.returnSlug || null;
+    this.transactionId = data.transactionId || null;
+    this.transactionStatus =
+      data.transactionStatus || TransactionStatusEnum.AUTHORIZED;
+  }
+}
+
+export class TransactionResponse extends TransactionResponseData {}
+export type PartialTransactionResponse = Partial<TransactionResponse>;
+export type ReadOnlyTransactionResponse = DeepReadonly<TransactionResponse>;

package/src/__api/models/UpdateCartCampaignOfferInput.ts

@@ -0,0 +1,25 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class UpdateCartCampaignOfferInputData {
+  accepted: boolean;
+  campaignOfferId: string;
+  campaignOfferProductId: string;
+  cartId: string;
+  productId: string;
+  variantId: string;
+
+  constructor(data: Partial<UpdateCartCampaignOfferInputData> = {}) {
+    this.accepted = data.accepted || false;
+    this.campaignOfferId = data.campaignOfferId || "";
+    this.campaignOfferProductId = data.campaignOfferProductId || "";
+    this.cartId = data.cartId || "";
+    this.productId = data.productId || "";
+    this.variantId = data.variantId || "";
+  }
+}
+
+export class UpdateCartCampaignOfferInput extends UpdateCartCampaignOfferInputData {}
+export type PartialUpdateCartCampaignOfferInput =
+  Partial<UpdateCartCampaignOfferInput>;
+export type ReadOnlyUpdateCartCampaignOfferInput =
+  DeepReadonly<UpdateCartCampaignOfferInput>;

package/src/__api/models/Variant.ts

@@ -0,0 +1,58 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { ProductAttributeValueData } from "./ProductAttributeValue";
+import { ProductImageData } from "./ProductImage";
+import { ProductPriceData } from "./ProductPrice";
+import { VariantStockData } from "./VariantStock";
+import { VariantValueRelationData } from "./VariantValueRelation";
+
+export class VariantData extends BaseModelData {
+  attributes: ProductAttributeValueData[] | null;
+  barcodeList: string[] | null;
+  hsCode: string | null;
+  images: ProductImageData[] | null;
+  isActive: boolean | null;
+  prices: ProductPriceData[];
+  sellIfOutOfStock: boolean | null;
+  sku: string | null;
+  stocks: VariantStockData[] | null;
+  variantValueIds: VariantValueRelationData[] | null;
+  weight: number | null;
+
+  constructor(data: Partial<VariantData> = {}) {
+    super(data);
+
+    this.attributes = data.attributes
+      ? data.attributes.map((p) => new ProductAttributeValueData(p))
+      : null;
+    this.barcodeList = data.barcodeList || null;
+    this.hsCode = data.hsCode || null;
+    this.images = data.images
+      ? data.images.map((p) => new ProductImageData(p))
+      : null;
+    this.isActive =
+      data.isActive !== undefined && data.isActive !== null
+        ? data.isActive
+        : null;
+    this.prices = data.prices
+      ? data.prices.map((p) => new ProductPriceData(p))
+      : [];
+    this.sellIfOutOfStock =
+      data.sellIfOutOfStock !== undefined && data.sellIfOutOfStock !== null
+        ? data.sellIfOutOfStock
+        : null;
+    this.sku = data.sku || null;
+    this.stocks = data.stocks
+      ? data.stocks.map((v) => new VariantStockData(v))
+      : null;
+    this.variantValueIds = data.variantValueIds
+      ? data.variantValueIds.map((v) => new VariantValueRelationData(v))
+      : null;
+    this.weight =
+      data.weight !== undefined && data.weight !== null ? data.weight : null;
+  }
+}
+
+export class Variant extends VariantData {}
+export type PartialVariant = Partial<Variant>;
+export type ReadOnlyVariant = DeepReadonly<Variant>;

package/src/__api/models/VariantStock.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class VariantStockData {
+  stockCount: number;
+  stockLocationId: string;
+
+  constructor(data: Partial<VariantStockData> = {}) {
+    this.stockCount = data.stockCount || 0;
+    this.stockLocationId = data.stockLocationId || "";
+  }
+}
+
+export class VariantStock extends VariantStockData {}
+export type PartialVariantStock = Partial<VariantStock>;
+export type ReadOnlyVariantStock = DeepReadonly<VariantStock>;

package/src/__api/models/VariantType.ts

@@ -0,0 +1,29 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { VariantSelectionTypeEnum } from "../types";
+import { VariantTypeTranslationData } from "./VariantTypeTranslation";
+import { VariantValueData } from "./VariantValue";
+
+export class VariantTypeData extends BaseModelData {
+  name: string;
+  selectionType: VariantSelectionTypeEnum;
+  translations: VariantTypeTranslationData[] | null;
+  values: VariantValueData[];
+
+  constructor(data: Partial<VariantTypeData> = {}) {
+    super(data);
+
+    this.name = data.name || "";
+    this.selectionType = data.selectionType || VariantSelectionTypeEnum.CHOICE;
+    this.translations = data.translations
+      ? data.translations.map((v) => new VariantTypeTranslationData(v))
+      : null;
+    this.values = data.values
+      ? data.values.map((v) => new VariantValueData(v))
+      : [];
+  }
+}
+
+export class VariantType extends VariantTypeData {}
+export type PartialVariantType = Partial<VariantType>;
+export type ReadOnlyVariantType = DeepReadonly<VariantType>;

package/src/__api/models/VariantTypeTranslation.ts

@@ -0,0 +1,21 @@
+import { DeepReadonly } from "ts-essentials";
+import { VariantValueTranslationData } from "./VariantValueTranslation";
+
+export class VariantTypeTranslationData {
+  locale: string;
+  name: string | null;
+  values: VariantValueTranslationData[] | null;
+
+  constructor(data: Partial<VariantTypeTranslationData> = {}) {
+    this.locale = data.locale || "";
+    this.name = data.name || null;
+    this.values = data.values
+      ? data.values.map((v) => new VariantValueTranslationData(v))
+      : null;
+  }
+}
+
+export class VariantTypeTranslation extends VariantTypeTranslationData {}
+export type PartialVariantTypeTranslation = Partial<VariantTypeTranslation>;
+export type ReadOnlyVariantTypeTranslation =
+  DeepReadonly<VariantTypeTranslation>;

package/src/__api/models/VariantValue.ts

@@ -0,0 +1,20 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+
+export class VariantValueData extends BaseModelData {
+  colorCode: string | null;
+  name: string;
+  thumbnailImageId: string | null;
+
+  constructor(data: Partial<VariantValueData> = {}) {
+    super(data);
+
+    this.colorCode = data.colorCode || null;
+    this.name = data.name || "";
+    this.thumbnailImageId = data.thumbnailImageId || null;
+  }
+}
+
+export class VariantValue extends VariantValueData {}
+export type PartialVariantValue = Partial<VariantValue>;
+export type ReadOnlyVariantValue = DeepReadonly<VariantValue>;

package/src/__api/models/VariantValueRelation.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class VariantValueRelationData {
+  variantTypeId: string;
+  variantValueId: string;
+
+  constructor(data: Partial<VariantValueRelationData> = {}) {
+    this.variantTypeId = data.variantTypeId || "";
+    this.variantValueId = data.variantValueId || "";
+  }
+}
+
+export class VariantValueRelation extends VariantValueRelationData {}
+export type PartialVariantValueRelation = Partial<VariantValueRelation>;
+export type ReadOnlyVariantValueRelation = DeepReadonly<VariantValueRelation>;

package/src/__api/models/VariantValueTranslation.ts

@@ -0,0 +1,16 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class VariantValueTranslationData {
+  id: string;
+  name: string | null;
+
+  constructor(data: Partial<VariantValueTranslationData> = {}) {
+    this.id = data.id || "";
+    this.name = data.name || null;
+  }
+}
+
+export class VariantValueTranslation extends VariantValueTranslationData {}
+export type PartialVariantValueTranslation = Partial<VariantValueTranslation>;
+export type ReadOnlyVariantValueTranslation =
+  DeepReadonly<VariantValueTranslation>;

package/src/__api/models/_base.ts

@@ -0,0 +1,26 @@
+export default class BaseModelData {
+  id: string;
+  createdAt: number;
+  updatedAt: number;
+  deleted?: boolean | null;
+
+  constructor(data: BaseModelParams = {}) {
+    this.id = data.id || Date.now() + "";
+    this.createdAt = data.createdAt || Date.now();
+    this.updatedAt = data.updatedAt || Date.now();
+    this.deleted = data.deleted || false;
+  }
+}
+
+export enum ModelStatus {
+  ACTIVE = 1,
+  PASSIVE = 2,
+  DELETED = 3,
+}
+
+export type BaseModelParams = {
+  id?: string;
+  createdAt?: number;
+  updatedAt?: number;
+  deleted?: boolean | null;
+};