@ikas/storefront-api 4.0.0-alpha.10

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@ikas/storefront-api",
+  "version": "4.0.0-alpha.10",
+  "author": "Umut Ozan Yıldırım",
+  "license": "ISC",
+  "description": "API functions that returns models from the ikas-storefront-models package.",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "files": [
+    "./src"
+  ],
+  "scripts": {
+    "pack": "npm pack",
+    "release": "npm publish",
+    "build": "rm -rf build && rollup -c",
+    "generate": "api-generator --generate --url=https://api.myikas.dev/api/sf/graphql --modelPath=./models.json --generatePath=./src/__api && prettier --write ./src/__api"
+  },
+  "dependencies": {
+    "@ikas/fe-api-client": "^1.0.13",
+    "ts-essentials": "^7.0.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^22.0.0",
+    "@ikas/storefront-config": "^4.0.0-alpha.10",
+    "@ikas/storefront-models": "^4.0.0-alpha.10",
+    "@rollup/plugin-node-resolve": "^13.3.0",
+    "prettier": "^2.2.1",
+    "rollup": "^2.75.6",
+    "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-typescript2": "^0.32.1",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "typescript": "^4.7.2",
+    "ttypescript": "^1.5.12",
+    "typescript-transform-paths": "^2.2.2",
+    "axios": "^0.26.0"
+  },
+  "peerDependencies": {
+    "@ikas/storefront-config": "^4.0.0-alpha.10",
+    "@ikas/storefront-models": "^4.0.0-alpha.10",
+    "axios": "^0.26.0"
+  }
+}

package/src/__api/models/AbandonedCartFlow.ts

@@ -0,0 +1,34 @@
+import { DeepReadonly } from "ts-essentials";
+import { CheckoutRecoveryEmailStatusEnum } from "../types";
+import { AbandonedCartFlowCustomerFilterData } from "./AbandonedCartFlowCustomerFilter";
+
+export class AbandonedCartFlowData {
+  campaignId: string | null;
+  canApplicable: boolean;
+  couponId: string | null;
+  customerFilters: AbandonedCartFlowCustomerFilterData | null;
+  flowId: string;
+  mailSendDate: any | null;
+  mailTranslationId: string | null;
+  recoverEmailStatus: CheckoutRecoveryEmailStatusEnum;
+  sendAfter: number;
+
+  constructor(data: Partial<AbandonedCartFlowData> = {}) {
+    this.campaignId = data.campaignId || null;
+    this.canApplicable = data.canApplicable || false;
+    this.couponId = data.couponId || null;
+    this.customerFilters = data.customerFilters
+      ? new AbandonedCartFlowCustomerFilterData(data.customerFilters)
+      : null;
+    this.flowId = data.flowId || "";
+    this.mailSendDate = data.mailSendDate || null;
+    this.mailTranslationId = data.mailTranslationId || null;
+    this.recoverEmailStatus =
+      data.recoverEmailStatus || CheckoutRecoveryEmailStatusEnum.NOT_SENT;
+    this.sendAfter = data.sendAfter || 0;
+  }
+}
+
+export class AbandonedCartFlow extends AbandonedCartFlowData {}
+export type PartialAbandonedCartFlow = Partial<AbandonedCartFlow>;
+export type ReadOnlyAbandonedCartFlow = DeepReadonly<AbandonedCartFlow>;

package/src/__api/models/AbandonedCartFlowCustomerFilter.ts

@@ -0,0 +1,25 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class AbandonedCartFlowCustomerFilterData {
+  sendOnlyActiveAccount: boolean | null;
+  sendOnlySubscribedToEmail: boolean | null;
+
+  constructor(data: Partial<AbandonedCartFlowCustomerFilterData> = {}) {
+    this.sendOnlyActiveAccount =
+      data.sendOnlyActiveAccount !== undefined &&
+      data.sendOnlyActiveAccount !== null
+        ? data.sendOnlyActiveAccount
+        : null;
+    this.sendOnlySubscribedToEmail =
+      data.sendOnlySubscribedToEmail !== undefined &&
+      data.sendOnlySubscribedToEmail !== null
+        ? data.sendOnlySubscribedToEmail
+        : null;
+  }
+}
+
+export class AbandonedCartFlowCustomerFilter extends AbandonedCartFlowCustomerFilterData {}
+export type PartialAbandonedCartFlowCustomerFilter =
+  Partial<AbandonedCartFlowCustomerFilter>;
+export type ReadOnlyAbandonedCartFlowCustomerFilter =
+  DeepReadonly<AbandonedCartFlowCustomerFilter>;

package/src/__api/models/AddItemToCartInput.ts

@@ -0,0 +1,29 @@
+import { DeepReadonly } from "ts-essentials";
+import { CartLineItemInputData } from "./CartLineItemInput";
+import { CartLineOptionInputData } from "./CartLineOptionInput";
+
+export class AddItemToCartInputData {
+  cartId: string | null;
+  item: CartLineItemInputData;
+  options: CartLineOptionInputData[] | null;
+  priceListId: string | null;
+  salesChannelId: string;
+  storefrontThemeId: string;
+
+  constructor(data: Partial<AddItemToCartInputData> = {}) {
+    this.cartId = data.cartId || null;
+    this.item = data.item
+      ? new CartLineItemInputData(data.item)
+      : new CartLineItemInputData();
+    this.options = data.options
+      ? data.options.map((c) => new CartLineOptionInputData(c))
+      : null;
+    this.priceListId = data.priceListId || null;
+    this.salesChannelId = data.salesChannelId || "";
+    this.storefrontThemeId = data.storefrontThemeId || "";
+  }
+}
+
+export class AddItemToCartInput extends AddItemToCartInputData {}
+export type PartialAddItemToCartInput = Partial<AddItemToCartInput>;
+export type ReadOnlyAddItemToCartInput = DeepReadonly<AddItemToCartInput>;

package/src/__api/models/AdditionalPrice.ts

@@ -0,0 +1,24 @@
+import { DeepReadonly } from "ts-essentials";
+import {
+  PaymentGatewayTransactionFeeTypeEnum,
+  PaymentGatewayAdditionalPriceTypeEnum,
+} from "../types";
+
+export class AdditionalPriceData {
+  amount: number;
+  amountType: PaymentGatewayTransactionFeeTypeEnum;
+  name: string;
+  type: PaymentGatewayAdditionalPriceTypeEnum;
+
+  constructor(data: Partial<AdditionalPriceData> = {}) {
+    this.amount = data.amount || 0;
+    this.amountType =
+      data.amountType || PaymentGatewayTransactionFeeTypeEnum.AMOUNT;
+    this.name = data.name || "";
+    this.type = data.type || PaymentGatewayAdditionalPriceTypeEnum.DECREMENT;
+  }
+}
+
+export class AdditionalPrice extends AdditionalPriceData {}
+export type PartialAdditionalPrice = Partial<AdditionalPrice>;
+export type ReadOnlyAdditionalPrice = DeepReadonly<AdditionalPrice>;

package/src/__api/models/ApplicableProductFilterValue.ts

@@ -0,0 +1,23 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class ApplicableProductFilterValueData {
+  colorCode: string | null;
+  id: string;
+  key: string;
+  name: string;
+  thumbnailImageId: string | null;
+
+  constructor(data: Partial<ApplicableProductFilterValueData> = {}) {
+    this.colorCode = data.colorCode || null;
+    this.id = data.id || "";
+    this.key = data.key || "";
+    this.name = data.name || "";
+    this.thumbnailImageId = data.thumbnailImageId || null;
+  }
+}
+
+export class ApplicableProductFilterValue extends ApplicableProductFilterValueData {}
+export type PartialApplicableProductFilterValue =
+  Partial<ApplicableProductFilterValue>;
+export type ReadOnlyApplicableProductFilterValue =
+  DeepReadonly<ApplicableProductFilterValue>;

package/src/__api/models/AppliedProduct.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class AppliedProductData {
+  productId: string | null;
+  variantId: string;
+
+  constructor(data: Partial<AppliedProductData> = {}) {
+    this.productId = data.productId || null;
+    this.variantId = data.variantId || "";
+  }
+}
+
+export class AppliedProduct extends AppliedProductData {}
+export type PartialAppliedProduct = Partial<AppliedProduct>;
+export type ReadOnlyAppliedProduct = DeepReadonly<AppliedProduct>;

package/src/__api/models/AppliedProductInput.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class AppliedProductInputData {
+  productId: string | null;
+  variantId: string;
+
+  constructor(data: Partial<AppliedProductInputData> = {}) {
+    this.productId = data.productId || null;
+    this.variantId = data.variantId || "";
+  }
+}
+
+export class AppliedProductInput extends AppliedProductInputData {}
+export type PartialAppliedProductInput = Partial<AppliedProductInput>;
+export type ReadOnlyAppliedProductInput = DeepReadonly<AppliedProductInput>;

package/src/__api/models/AvailableShippingMethod.ts

@@ -0,0 +1,24 @@
+import { DeepReadonly } from "ts-essentials";
+import { ShippingMethodEnum } from "../types";
+
+export class AvailableShippingMethodData {
+  price: number;
+  rateName: string;
+  shippingMethod: ShippingMethodEnum;
+  shippingSettingsId: string;
+  shippingZoneRateId: string;
+
+  constructor(data: Partial<AvailableShippingMethodData> = {}) {
+    this.price = data.price || 0;
+    this.rateName = data.rateName || "";
+    this.shippingMethod =
+      data.shippingMethod || ShippingMethodEnum.CLICK_AND_COLLECT;
+    this.shippingSettingsId = data.shippingSettingsId || "";
+    this.shippingZoneRateId = data.shippingZoneRateId || "";
+  }
+}
+
+export class AvailableShippingMethod extends AvailableShippingMethodData {}
+export type PartialAvailableShippingMethod = Partial<AvailableShippingMethod>;
+export type ReadOnlyAvailableShippingMethod =
+  DeepReadonly<AvailableShippingMethod>;

package/src/__api/models/Blog.ts

@@ -0,0 +1,55 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { BlogContentData } from "./BlogContent";
+import { BlogCategoryData } from "./BlogCategory";
+import { BlogMetadataData } from "./BlogMetadata";
+import { BlogTagData } from "./BlogTag";
+import { BlogWriterData } from "./BlogWriter";
+
+export class BlogData extends BaseModelData {
+  blogContent: BlogContentData;
+  category: BlogCategoryData;
+  categoryId: string;
+  imageId: string;
+  isPublished: boolean;
+  locale: string | null;
+  metadata: BlogMetadataData;
+  publishedAt: any | null;
+  shortDescription: string;
+  storefrontId: string;
+  tagIds: string[] | null;
+  tags: BlogTagData[] | null;
+  title: string;
+  writer: BlogWriterData;
+
+  constructor(data: Partial<BlogData> = {}) {
+    super(data);
+
+    this.blogContent = data.blogContent
+      ? new BlogContentData(data.blogContent)
+      : new BlogContentData();
+    this.category = data.category
+      ? new BlogCategoryData(data.category)
+      : new BlogCategoryData();
+    this.categoryId = data.categoryId || "";
+    this.imageId = data.imageId || "";
+    this.isPublished = data.isPublished || false;
+    this.locale = data.locale || null;
+    this.metadata = data.metadata
+      ? new BlogMetadataData(data.metadata)
+      : new BlogMetadataData();
+    this.publishedAt = data.publishedAt || null;
+    this.shortDescription = data.shortDescription || "";
+    this.storefrontId = data.storefrontId || "";
+    this.tagIds = data.tagIds || null;
+    this.tags = data.tags ? data.tags.map((b) => new BlogTagData(b)) : null;
+    this.title = data.title || "";
+    this.writer = data.writer
+      ? new BlogWriterData(data.writer)
+      : new BlogWriterData();
+  }
+}
+
+export class Blog extends BlogData {}
+export type PartialBlog = Partial<Blog>;
+export type ReadOnlyBlog = DeepReadonly<Blog>;

package/src/__api/models/BlogCategory.ts

@@ -0,0 +1,23 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { BlogMetadataData } from "./BlogMetadata";
+
+export class BlogCategoryData extends BaseModelData {
+  imageId: string;
+  metadata: BlogMetadataData;
+  name: string;
+
+  constructor(data: Partial<BlogCategoryData> = {}) {
+    super(data);
+
+    this.imageId = data.imageId || "";
+    this.metadata = data.metadata
+      ? new BlogMetadataData(data.metadata)
+      : new BlogMetadataData();
+    this.name = data.name || "";
+  }
+}
+
+export class BlogCategory extends BlogCategoryData {}
+export type PartialBlogCategory = Partial<BlogCategory>;
+export type ReadOnlyBlogCategory = DeepReadonly<BlogCategory>;

package/src/__api/models/BlogCategoryPaginationResponse.ts

@@ -0,0 +1,24 @@
+import { DeepReadonly } from "ts-essentials";
+import { BlogCategoryData } from "./BlogCategory";
+
+export class BlogCategoryPaginationResponseData {
+  count: number;
+  data: BlogCategoryData[];
+  hasNext: boolean;
+  limit: number;
+  page: number;
+
+  constructor(data: Partial<BlogCategoryPaginationResponseData> = {}) {
+    this.count = data.count || 0;
+    this.data = data.data ? data.data.map((b) => new BlogCategoryData(b)) : [];
+    this.hasNext = data.hasNext || false;
+    this.limit = data.limit || 0;
+    this.page = data.page || 0;
+  }
+}
+
+export class BlogCategoryPaginationResponse extends BlogCategoryPaginationResponseData {}
+export type PartialBlogCategoryPaginationResponse =
+  Partial<BlogCategoryPaginationResponse>;
+export type ReadOnlyBlogCategoryPaginationResponse =
+  DeepReadonly<BlogCategoryPaginationResponse>;

package/src/__api/models/BlogContent.ts

@@ -0,0 +1,20 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+
+export class BlogContentData extends BaseModelData {
+  content: string;
+  contentData: string | null;
+  contentSource: string | null;
+
+  constructor(data: Partial<BlogContentData> = {}) {
+    super(data);
+
+    this.content = data.content || "";
+    this.contentData = data.contentData || null;
+    this.contentSource = data.contentSource || null;
+  }
+}
+
+export class BlogContent extends BlogContentData {}
+export type PartialBlogContent = Partial<BlogContent>;
+export type ReadOnlyBlogContent = DeepReadonly<BlogContent>;

package/src/__api/models/BlogMetadata.ts

@@ -0,0 +1,32 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { BlogMetadataTargetTypeEnum } from "../types";
+
+export class BlogMetadataData extends BaseModelData {
+  canonicals: string[] | null;
+  description: string | null;
+  disableIndex: boolean | null;
+  pageTitle: string | null;
+  slug: string;
+  targetId: string | null;
+  targetType: BlogMetadataTargetTypeEnum | null;
+
+  constructor(data: Partial<BlogMetadataData> = {}) {
+    super(data);
+
+    this.canonicals = data.canonicals || null;
+    this.description = data.description || null;
+    this.disableIndex =
+      data.disableIndex !== undefined && data.disableIndex !== null
+        ? data.disableIndex
+        : null;
+    this.pageTitle = data.pageTitle || null;
+    this.slug = data.slug || "";
+    this.targetId = data.targetId || null;
+    this.targetType = data.targetType || null;
+  }
+}
+
+export class BlogMetadata extends BlogMetadataData {}
+export type PartialBlogMetadata = Partial<BlogMetadata>;
+export type ReadOnlyBlogMetadata = DeepReadonly<BlogMetadata>;

package/src/__api/models/BlogMetadataPaginationResponse.ts

@@ -0,0 +1,24 @@
+import { DeepReadonly } from "ts-essentials";
+import { BlogMetadataData } from "./BlogMetadata";
+
+export class BlogMetadataPaginationResponseData {
+  count: number;
+  data: BlogMetadataData[];
+  hasNext: boolean;
+  limit: number;
+  page: number;
+
+  constructor(data: Partial<BlogMetadataPaginationResponseData> = {}) {
+    this.count = data.count || 0;
+    this.data = data.data ? data.data.map((b) => new BlogMetadataData(b)) : [];
+    this.hasNext = data.hasNext || false;
+    this.limit = data.limit || 0;
+    this.page = data.page || 0;
+  }
+}
+
+export class BlogMetadataPaginationResponse extends BlogMetadataPaginationResponseData {}
+export type PartialBlogMetadataPaginationResponse =
+  Partial<BlogMetadataPaginationResponse>;
+export type ReadOnlyBlogMetadataPaginationResponse =
+  DeepReadonly<BlogMetadataPaginationResponse>;

package/src/__api/models/BlogMetadataTargetTypeEnumFilter.ts

@@ -0,0 +1,22 @@
+import { DeepReadonly } from "ts-essentials";
+import { BlogMetadataTargetTypeEnum } from "../types";
+
+export class BlogMetadataTargetTypeEnumFilterData {
+  eq: BlogMetadataTargetTypeEnum | null;
+  in: BlogMetadataTargetTypeEnum[] | null;
+  ne: BlogMetadataTargetTypeEnum | null;
+  nin: BlogMetadataTargetTypeEnum[] | null;
+
+  constructor(data: Partial<BlogMetadataTargetTypeEnumFilterData> = {}) {
+    this.eq = data.eq || null;
+    this.in = data.in || null;
+    this.ne = data.ne || null;
+    this.nin = data.nin || null;
+  }
+}
+
+export class BlogMetadataTargetTypeEnumFilter extends BlogMetadataTargetTypeEnumFilterData {}
+export type PartialBlogMetadataTargetTypeEnumFilter =
+  Partial<BlogMetadataTargetTypeEnumFilter>;
+export type ReadOnlyBlogMetadataTargetTypeEnumFilter =
+  DeepReadonly<BlogMetadataTargetTypeEnumFilter>;

package/src/__api/models/BlogPaginationResponse.ts

@@ -0,0 +1,23 @@
+import { DeepReadonly } from "ts-essentials";
+import { BlogData } from "./Blog";
+
+export class BlogPaginationResponseData {
+  count: number;
+  data: BlogData[];
+  hasNext: boolean;
+  limit: number;
+  page: number;
+
+  constructor(data: Partial<BlogPaginationResponseData> = {}) {
+    this.count = data.count || 0;
+    this.data = data.data ? data.data.map((b) => new BlogData(b)) : [];
+    this.hasNext = data.hasNext || false;
+    this.limit = data.limit || 0;
+    this.page = data.page || 0;
+  }
+}
+
+export class BlogPaginationResponse extends BlogPaginationResponseData {}
+export type PartialBlogPaginationResponse = Partial<BlogPaginationResponse>;
+export type ReadOnlyBlogPaginationResponse =
+  DeepReadonly<BlogPaginationResponse>;

package/src/__api/models/BlogTag.ts

@@ -0,0 +1,16 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+
+export class BlogTagData extends BaseModelData {
+  name: string;
+
+  constructor(data: Partial<BlogTagData> = {}) {
+    super(data);
+
+    this.name = data.name || "";
+  }
+}
+
+export class BlogTag extends BlogTagData {}
+export type PartialBlogTag = Partial<BlogTag>;
+export type ReadOnlyBlogTag = DeepReadonly<BlogTag>;

package/src/__api/models/BlogWriter.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class BlogWriterData {
+  firstName: string;
+  lastName: string;
+
+  constructor(data: Partial<BlogWriterData> = {}) {
+    this.firstName = data.firstName || "";
+    this.lastName = data.lastName || "";
+  }
+}
+
+export class BlogWriter extends BlogWriterData {}
+export type PartialBlogWriter = Partial<BlogWriter>;
+export type ReadOnlyBlogWriter = DeepReadonly<BlogWriter>;

package/src/__api/models/BooleanFilterInput.ts

@@ -0,0 +1,13 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class BooleanFilterInputData {
+  eq: boolean | null;
+
+  constructor(data: Partial<BooleanFilterInputData> = {}) {
+    this.eq = data.eq !== undefined && data.eq !== null ? data.eq : null;
+  }
+}
+
+export class BooleanFilterInput extends BooleanFilterInputData {}
+export type PartialBooleanFilterInput = Partial<BooleanFilterInput>;
+export type ReadOnlyBooleanFilterInput = DeepReadonly<BooleanFilterInput>;

package/src/__api/models/BuyX.ts

@@ -0,0 +1,20 @@
+import { DeepReadonly } from "ts-essentials";
+import { CampaignFilterData } from "./CampaignFilter";
+
+export class BuyXData {
+  amount: number;
+  applyByQuantity: boolean;
+  filter: CampaignFilterData;
+
+  constructor(data: Partial<BuyXData> = {}) {
+    this.amount = data.amount || 0;
+    this.applyByQuantity = data.applyByQuantity || false;
+    this.filter = data.filter
+      ? new CampaignFilterData(data.filter)
+      : new CampaignFilterData();
+  }
+}
+
+export class BuyX extends BuyXData {}
+export type PartialBuyX = Partial<BuyX>;
+export type ReadOnlyBuyX = DeepReadonly<BuyX>;

package/src/__api/models/BuyXThenGetY.ts

@@ -0,0 +1,22 @@
+import { DeepReadonly } from "ts-essentials";
+import { BuyXData } from "./BuyX";
+import { GetYData } from "./GetY";
+
+export class BuyXThenGetYData {
+  buyX: BuyXData;
+  getY: GetYData;
+  maxUsagePerOrder: number | null;
+
+  constructor(data: Partial<BuyXThenGetYData> = {}) {
+    this.buyX = data.buyX ? new BuyXData(data.buyX) : new BuyXData();
+    this.getY = data.getY ? new GetYData(data.getY) : new GetYData();
+    this.maxUsagePerOrder =
+      data.maxUsagePerOrder !== undefined && data.maxUsagePerOrder !== null
+        ? data.maxUsagePerOrder
+        : null;
+  }
+}
+
+export class BuyXThenGetY extends BuyXThenGetYData {}
+export type PartialBuyXThenGetY = Partial<BuyXThenGetY>;
+export type ReadOnlyBuyXThenGetY = DeepReadonly<BuyXThenGetY>;

package/src/__api/models/Campaign.ts

@@ -0,0 +1,75 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import {
+  CampaignApplicablePriceEnum,
+  CampaignCreatedForEnum,
+  CampaignTypeEnum,
+} from "../types";
+import { BuyXThenGetYData } from "./BuyXThenGetY";
+import { CampaignDateRangeFieldData } from "./CampaignDateRangeField";
+import { FixedDiscountData } from "./FixedDiscount";
+
+export class CampaignData extends BaseModelData {
+  applicableCustomerGroupIds: string[] | null;
+  applicableCustomerIds: string[] | null;
+  applicablePrice: CampaignApplicablePriceEnum;
+  buyXThenGetY: BuyXThenGetYData | null;
+  canCombineWithOtherCampaigns: boolean;
+  createdFor: CampaignCreatedForEnum | null;
+  currencyCodes: string[] | null;
+  dateRange: CampaignDateRangeFieldData | null;
+  fixedDiscount: FixedDiscountData | null;
+  hasCoupon: boolean;
+  includeDiscountedProducts: boolean | null;
+  salesChannelIds: string[] | null;
+  title: string;
+  type: CampaignTypeEnum;
+  usageCount: number;
+  usageLimit: number | null;
+  usageLimitPerCustomer: number | null;
+
+  constructor(data: Partial<CampaignData> = {}) {
+    super(data);
+
+    this.applicableCustomerGroupIds = data.applicableCustomerGroupIds || null;
+    this.applicableCustomerIds = data.applicableCustomerIds || null;
+    this.applicablePrice =
+      data.applicablePrice || CampaignApplicablePriceEnum.DISCOUNT_PRICE;
+    this.buyXThenGetY = data.buyXThenGetY
+      ? new BuyXThenGetYData(data.buyXThenGetY)
+      : null;
+    this.canCombineWithOtherCampaigns =
+      data.canCombineWithOtherCampaigns || false;
+    this.createdFor = data.createdFor || null;
+    this.currencyCodes = data.currencyCodes || null;
+    this.dateRange = data.dateRange
+      ? new CampaignDateRangeFieldData(data.dateRange)
+      : null;
+    this.fixedDiscount = data.fixedDiscount
+      ? new FixedDiscountData(data.fixedDiscount)
+      : null;
+    this.hasCoupon = data.hasCoupon || false;
+    this.includeDiscountedProducts =
+      data.includeDiscountedProducts !== undefined &&
+      data.includeDiscountedProducts !== null
+        ? data.includeDiscountedProducts
+        : null;
+    this.salesChannelIds = data.salesChannelIds || null;
+    this.title = data.title || "";
+    this.type = data.type || CampaignTypeEnum.BUY_X_THEN_GET_Y;
+    this.usageCount = data.usageCount || 0;
+    this.usageLimit =
+      data.usageLimit !== undefined && data.usageLimit !== null
+        ? data.usageLimit
+        : null;
+    this.usageLimitPerCustomer =
+      data.usageLimitPerCustomer !== undefined &&
+      data.usageLimitPerCustomer !== null
+        ? data.usageLimitPerCustomer
+        : null;
+  }
+}
+
+export class Campaign extends CampaignData {}
+export type PartialCampaign = Partial<Campaign>;
+export type ReadOnlyCampaign = DeepReadonly<Campaign>;

package/src/__api/models/CampaignDateRangeField.ts

@@ -0,0 +1,16 @@
+import { DeepReadonly } from "ts-essentials";
+
+export class CampaignDateRangeFieldData {
+  end: any | null;
+  start: any | null;
+
+  constructor(data: Partial<CampaignDateRangeFieldData> = {}) {
+    this.end = data.end || null;
+    this.start = data.start || null;
+  }
+}
+
+export class CampaignDateRangeField extends CampaignDateRangeFieldData {}
+export type PartialCampaignDateRangeField = Partial<CampaignDateRangeField>;
+export type ReadOnlyCampaignDateRangeField =
+  DeepReadonly<CampaignDateRangeField>;