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

package/src/api/product/index.ts

@@ -0,0 +1,354 @@
+import { APIResponse } from "@ikas/fe-api-client";
+import { SearchProduct } from "../../__api/types";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+
+import { QueryParams as ListProductBackInStockRemindQueryParams } from "../../__api/queries/listProductBackInStockRemind";
+import { QueryParams as SearchProductsQueryParams } from "../../__api/queries/searchProducts";
+import { QueryParams as GetProductFilterDataQueryParams } from "../../__api/queries/getProductFilterData";
+import { QueryParams as GetRelatedProductsQueryParams } from "../../__api/queries/getRelatedProducts";
+import { QueryParams as ListProductAttributeQueryParams } from "../../__api/queries/listProductAttribute";
+import { QueryParams as GetProductCampaignsQueryParams } from "../../__api/queries/getProductCampaigns";
+import { QueryParams as GetOrderLineFileQueryParams } from "../../__api/mutations/getOrderLineFile";
+import { QueryParams as ListProductOptionSetQueryParams } from "../../__api/queries/listProductOptionSet";
+import { QueryParams as SaveProductBackInStockRemindQueryParams } from "../../__api/mutations/saveProductBackInStockRemind";
+
+import {
+  IkasBrandOrderType,
+  IkasCategoryProductsOrderType,
+  IkasFilterCategory,
+  IkasProduct,
+  IkasProductAttribute,
+  IkasProductAttributeType,
+  IkasProductCampaign,
+  IkasProductFilter,
+  IkasProductOptionSet,
+  IkasProductPrice,
+  initIkasProduct,
+  initIkasProductAttribute,
+  initIkasProductOptionSet,
+} from "@ikas/storefront-models";
+
+export type {
+  ListProductBackInStockRemindQueryParams,
+  SearchProductsQueryParams,
+  GetProductFilterDataQueryParams,
+  GetRelatedProductsQueryParams,
+  ListProductAttributeQueryParams,
+  GetProductCampaignsQueryParams,
+  GetOrderLineFileQueryParams,
+  ListProductOptionSetQueryParams,
+  SaveProductBackInStockRemindQueryParams,
+};
+
+export async function listProductBackInStockRemind(
+  params: ListProductBackInStockRemindQueryParams
+) {
+  const _listProductBackInStockRemind = (
+    await import("../../__api/queries/listProductBackInStockRemind")
+  ).default;
+  return await _listProductBackInStockRemind(params);
+}
+
+export async function saveProductBackInStockRemind(
+  params: SaveProductBackInStockRemindQueryParams
+) {
+  const _saveProductBackInStockRemind = (
+    await import("../../__api/mutations/saveProductBackInStockRemind")
+  ).default;
+  return await _saveProductBackInStockRemind(params);
+}
+
+export async function searchProducts(params: SearchProductsQueryParams) {
+  const _searchProducts = (await import("../../__api/queries/searchProducts"))
+    .default;
+  const response = await _searchProducts(
+    params,
+    await getSearchProductFields()
+  );
+  const products = response.data?.results.map(simpleToProduct);
+
+  products?.forEach((p) =>
+    initIkasProduct(p, IkasStorefrontConfig.getCurrentLocale())
+  );
+
+  return new APIResponse({
+    ...response.data,
+    data: products,
+  });
+}
+
+export async function getProductFilterData(
+  params: GetProductFilterDataQueryParams
+) {
+  const _getProductFilterData = (
+    await import("../../__api/queries/getProductFilterData")
+  ).default;
+  const response = await _getProductFilterData(params);
+  const filters: IkasProductFilter[] = response.data?.filters as any;
+
+  const categories: IkasFilterCategory[] | null =
+    (response.data?.categories as any) || null;
+
+  return new APIResponse(
+    response.data
+      ? {
+          filters,
+          categories,
+        }
+      : null,
+    response.graphQLErrors
+  );
+}
+
+export async function getRelatedProducts(
+  params: GetRelatedProductsQueryParams
+) {
+  const _getRelatedProducts = (
+    await import("../../__api/queries/getRelatedProducts")
+  ).default;
+  const response = await _getRelatedProducts(params);
+  const products = response.data.getRelatedProducts.map((d: SearchProduct) =>
+    simpleToProduct(d)
+  ) as IkasProduct[];
+
+  products.forEach((p) =>
+    initIkasProduct(p, IkasStorefrontConfig.getCurrentLocale())
+  );
+
+  return new APIResponse(
+    response.data
+      ? {
+          data: products,
+          count: response.data.getRelatedProducts.length,
+          facets: null,
+          limit: 20,
+          page: 1,
+          totalCount: response.data.getRelatedProducts.length,
+        }
+      : null,
+    response.graphQLErrors
+  );
+}
+
+export async function listProductAttribute(
+  params: ListProductAttributeQueryParams
+) {
+  const _listProductAttribute = (
+    await import("../../__api/queries/listProductAttribute")
+  ).default;
+  const response = await _listProductAttribute(params);
+  const data: IkasProductAttribute[] | undefined = response.data as any;
+
+  data?.forEach((pa) =>
+    initIkasProductAttribute(pa, IkasStorefrontConfig.getCurrentLocale())
+  );
+
+  return new APIResponse(data, response.graphQLErrors);
+}
+
+export async function getProductCampaigns(
+  params: GetProductCampaignsQueryParams
+) {
+  const _getProductCampaigns = (
+    await import("../../__api/queries/getProductCampaigns")
+  ).default;
+  const response = await _getProductCampaigns(params);
+  return new APIResponse(
+    response.data?.map((d) => d as unknown as IkasProductCampaign),
+    response.graphQLErrors
+  );
+}
+
+export async function getOrderLineFile(params: GetOrderLineFileQueryParams) {
+  const _getOrderLineFile = (
+    await import("../../__api/mutations/getOrderLineFile")
+  ).default;
+  return await _getOrderLineFile(params);
+}
+
+export async function listProductOptionSet(
+  params: ListProductOptionSetQueryParams
+) {
+  const _listProductOptionSet = (
+    await import("../../__api/queries/listProductOptionSet")
+  ).default;
+  const response = await _listProductOptionSet(params);
+  const data: IkasProductOptionSet[] | undefined = response.data as any;
+
+  data?.forEach((pos) =>
+    initIkasProductOptionSet(pos, IkasStorefrontConfig.getCurrentLocale())
+  );
+
+  return new APIResponse(data, response.graphQLErrors);
+}
+
+async function getSearchProductFields() {
+  const SearchProductsResponseField = (
+    await import("../../__api/queries/searchProducts")
+  ).ResponseField;
+  type SearchResponseFieldKey = keyof typeof SearchProductsResponseField;
+  const EXCLUDED_SEARCH_PRODUCTS_FIELDS: SearchResponseFieldKey[] = ["DATA"];
+
+  return Object.entries(SearchProductsResponseField)
+    .filter(
+      ([key]) =>
+        !EXCLUDED_SEARCH_PRODUCTS_FIELDS.includes(key as SearchResponseFieldKey)
+    )
+    .map((entry) => entry[1]);
+}
+
+function simpleToProduct(simple: SearchProduct): IkasProduct {
+  const isLocal = process.env.NEXT_PUBLIC_ENV === "local";
+
+  return {
+    id: simple.id,
+    type: simple.type as any,
+    attributes:
+      simple.attributes?.map((a) => ({
+        ...a,
+        value: a.value,
+        productAttributeId: a.productAttribute?.id || null,
+        productAttributeOptionId: a.productAttributeOption?.id || null,
+        productAttribute: {
+          id: a.productAttribute?.id || "",
+          name: a.productAttribute?.name || "",
+          description: null,
+          type: a.productAttribute?.type as unknown as IkasProductAttributeType,
+          tableTemplate: a.productAttribute?.tableTemplate
+            ? a.productAttribute.tableTemplate
+            : null,
+          options: null,
+        },
+        productAttributeOption: a.productAttributeOption,
+      })) || [],
+    brand: simple.brand
+      ? {
+          ...simple.brand,
+          id: simple.brand.id,
+          name: simple.brand.name,
+          createdAt: 0,
+          updatedAt: 0,
+          description: null,
+          imageId: null,
+          orderType: IkasBrandOrderType.BEST_SELLER,
+          metaData: {
+            id: "",
+            createdAt: 0,
+            updatedAt: 0,
+            slug: simple.brand.slug || "",
+          },
+        }
+      : null,
+    categories:
+      simple.categories?.map((c) => ({
+        ...c,
+        categoryPath: null,
+        description: null,
+        imageId: null,
+        parentId: null,
+        metaData: null,
+        categoryPathItems: [],
+        createdAt: 0,
+        updatedAt: 0,
+        orderType: IkasCategoryProductsOrderType.BEST_SELLER,
+      })) || [],
+    tags: simple.tags || [],
+    description: simple.description || "",
+    metaData:
+      {
+        ...simple.metaData,
+        id: "",
+        createdAt: 0,
+        updatedAt: 0,
+        slug: simple.metaData?.slug || "",
+      } || null,
+    name: simple.name,
+    shortDescription: simple.shortDescription || "",
+    productOptionSetId: simple.productOptionSetId,
+    variantTypes: simple.productVariantTypes.map((pvt) => ({
+      variantType: {
+        id: pvt.variantType.id,
+        name: pvt.variantType.name,
+        selectionType: pvt.variantType.selectionType as any,
+        values: pvt.variantType.values
+          .map((v) => ({
+            id: v.id,
+            colorCode: v.colorCode,
+            name: v.name,
+            thumbnailImageId: v.thumbnailImageId,
+            variantTypeId: pvt.variantType.id,
+          }))
+          .filter((v) => pvt.variantValueIds.includes(v.id)),
+      },
+      variantValueIds: pvt.variantValueIds,
+    })),
+    variants: simple.variants.map((v) => ({
+      ...v,
+      id: v.id,
+      productId: simple.id,
+      images:
+        v.images?.map((i) => ({
+          imageId: i.id,
+          isMain: i.isMain || false,
+          isVideo: i.isVideo,
+          order: i.order,
+        })) || null,
+      sellIfOutOfStock: v.sellIfOutOfStock || false,
+      attributes:
+        v.attributes?.map((a) => ({
+          ...a,
+          value: a.value,
+          productAttributeId: a.productAttribute?.id || null,
+          productAttributeOptionId: a.productAttributeOption?.id || null,
+          productAttribute: {
+            id: a.productAttribute?.id || "",
+            name: a.productAttribute?.name || "",
+            description: "",
+            type: a.productAttribute
+              ?.type as unknown as IkasProductAttributeType,
+            tableTemplate: a.productAttribute?.tableTemplate
+              ? a.productAttribute.tableTemplate
+              : null,
+            options: null,
+          },
+          productAttributeOption: a.productAttributeOption,
+        })) || [],
+      sku: v.sku,
+      barcodeList: v.barcodeList || null,
+      price: v.prices?.find((p) =>
+        IkasStorefrontConfig.getPriceListId()
+          ? p.priceListId === IkasStorefrontConfig.getPriceListId()
+          : p.priceListId === null
+      ) as unknown as IkasProductPrice,
+      stock:
+        v.stocks
+          ?.filter(
+            (s) =>
+              isLocal ||
+              IkasStorefrontConfig.getIsEditor() ||
+              IkasStorefrontConfig.getStockLocationIds()?.includes(
+                s.stockLocationId
+              )
+          )
+          .reduce((total, current) => current.stockCount + total, 0) || 0,
+      variantValues:
+        v.variantValues?.map((vv) => {
+          const pvt = simple.productVariantTypes.find(
+            (pvt) => pvt.variantType.id === vv.variantTypeId
+          );
+          const variantValue = pvt?.variantType.values.find(
+            (_vv) => _vv.id === vv.variantValueId
+          );
+
+          return {
+            id: vv.variantValueId,
+            name: variantValue?.name || "",
+            colorCode: variantValue?.colorCode || "",
+            thumbnailImageId: variantValue?.thumbnailImageId || "",
+            variantTypeId: pvt?.variantType.id || "",
+          };
+        }) || [],
+      isActive: v.isActive || false,
+    })),
+  };
+}

package/src/api/raffle/index.ts

@@ -0,0 +1,80 @@
+import { APIResponse } from "@ikas/fe-api-client";
+import {
+  IkasRaffle,
+  IkasRaffleMetaData,
+  IkasRaffleParticipant,
+  initIkasRaffle,
+} from "@ikas/storefront-models";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+
+import { QueryParams as ListRaffleQueryParams } from "../../__api/queries/listRaffle";
+import { QueryParams as SaveRaffleParticipantQueryParams } from "../../__api/mutations/saveRaffleParticipant";
+import { QueryParams as ListRaffleMetadataQueryParams } from "../../__api/queries/listRaffleMetadata";
+import { QueryParams as GetRafflesByCustomerIdQueryParams } from "../../__api/queries/getRafflesByCustomerId";
+
+export type {
+  ListRaffleQueryParams,
+  SaveRaffleParticipantQueryParams,
+  ListRaffleMetadataQueryParams,
+  GetRafflesByCustomerIdQueryParams,
+};
+
+export async function listRaffle(params: ListRaffleQueryParams) {
+  const _listRaffle = (await import("../../__api/queries/listRaffle")).default;
+  const response = await _listRaffle(params);
+  const data: IkasRaffle[] | undefined = response.data as any;
+
+  data?.forEach((r) =>
+    initIkasRaffle(r, IkasStorefrontConfig.getCurrentLocale())
+  );
+
+  return new APIResponse(
+    {
+      ...response.data,
+      data: data,
+    },
+    response.graphQLErrors
+  );
+}
+
+export async function saveRaffleParticipant(
+  params: SaveRaffleParticipantQueryParams
+) {
+  const _saveRaffleParticipant = (
+    await import("../../__api/mutations/saveRaffleParticipant")
+  ).default;
+  const response = await _saveRaffleParticipant(params);
+  return new APIResponse(
+    response.data ? (response.data as IkasRaffleParticipant) : null,
+    response.graphQLErrors
+  );
+}
+
+export async function listRaffleMetaData(
+  params: ListRaffleMetadataQueryParams
+) {
+  const _listRaffleMetadata = (
+    await import("../../__api/queries/listRaffleMetadata")
+  ).default;
+  const response = await _listRaffleMetadata(params);
+  return new APIResponse(
+    response.data?.map((d) => d as IkasRaffleMetaData),
+    response.graphQLErrors
+  );
+}
+
+export async function getRafflesByCustomerId(
+  params: GetRafflesByCustomerIdQueryParams
+) {
+  const _getRafflesByCustomerId = (
+    await import("../../__api/queries/getRafflesByCustomerId")
+  ).default;
+  const response = await _getRafflesByCustomerId(params);
+  const data: IkasRaffle[] | undefined = response.data as any;
+
+  data?.forEach((r) =>
+    initIkasRaffle(r, IkasStorefrontConfig.getCurrentLocale())
+  );
+
+  return new APIResponse(data, response.graphQLErrors);
+}

package/src/api/storefront/index.ts

@@ -0,0 +1,30 @@
+import { APIResponse } from "@ikas/fe-api-client";
+import {
+  IkasCustomerReviewSettings,
+  IkasMerchantSettings,
+  IkasProductBackInStockSettings,
+  IkasSalesChannel,
+  IkasStorefront,
+} from "@ikas/storefront-models";
+
+export async function getStorefrontSettings() {
+  const _getStorefrontSettings = (
+    await import("../../__api/queries/getStorefrontSettings")
+  ).default;
+  const response = await _getStorefrontSettings();
+  return new APIResponse(
+    response.data as IkasStorefrontSettings | undefined,
+    response.graphQLErrors
+  );
+}
+
+export type IkasStorefrontSettings = {
+  storefront: IkasStorefront;
+  salesChannel: IkasSalesChannel;
+  localizationMap: Record<string, any>;
+  domain: string;
+  customerReviewSettings: IkasCustomerReviewSettings | null;
+  productBackInStockSettings: IkasProductBackInStockSettings | null;
+  storefrontJSScripts: string[];
+  merchantSettings: IkasMerchantSettings;
+};

package/src/index.ts

@@ -0,0 +1,68 @@
+import { APIErrorCode, Config } from "@ikas/fe-api-client";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+
+const onConfigChange = () => {
+  Config.URL = IkasStorefrontConfig.getApiUrl() || "";
+  Config.HEADERS = {
+    "x-api-key": IkasStorefrontConfig.getApiKey() || "",
+    "x-sfid": IkasStorefrontConfig.getStorefrontId() || "",
+    "x-sfrid": IkasStorefrontConfig.getStorefrontRoutingId() || "",
+    "x-sid": IkasStorefrontConfig.getSessionId() || "",
+    "x-vid": IkasStorefrontConfig.getVisitorId() || "",
+  };
+
+  if (IkasStorefrontConfig.getCustomerToken()) {
+    Config.TOKEN = IkasStorefrontConfig.getCustomerToken() || "";
+  }
+
+  if (IkasStorefrontConfig.getLoginRequiredCallback()) {
+    Config.ON_ERROR = {
+      errors: [
+        {
+          errorCode: APIErrorCode.LOGIN_REQUIRED,
+          callback: IkasStorefrontConfig.getLoginRequiredCallback()!,
+        },
+      ],
+    };
+  }
+};
+
+IkasStorefrontConfig.addObserver({
+  id: "ikas-storefront-api",
+  callback: onConfigChange,
+});
+
+export * from "./api/blog";
+export * from "./api/brand";
+export * from "./api/cart";
+export * from "./api/category";
+export * from "./api/checkout";
+export * from "./api/customer";
+export * from "./api/file-upload";
+export * from "./api/html-meta-data";
+export * from "./api/location";
+export * from "./api/masterpass";
+export * from "./api/merchant";
+export * from "./api/product";
+export * from "./api/raffle";
+export * from "./api/storefront";
+
+export { SaveMyCustomerInput } from "./__api/models/SaveMyCustomerInput";
+export { SaveCartInput } from "./__api/models/SaveCartInput";
+export { CheckStocksLineInput } from "./__api/models/CheckStocksLineInput";
+export {
+  SortByDirectionEnum,
+  SortByTypeEnum,
+  MasterPassOperationTypeEnum,
+} from "./__api/types";
+export type {
+  SearchInputOrderByInput,
+  CreateStripePaymentIntentResponse,
+  RetrieveInstallmentInfoResponse,
+  TransactionResponse,
+  UpdateCartCampaignOfferInput,
+  CartLineOptionInput,
+} from "./__api/types";
+
+export { APIResponse } from "@ikas/fe-api-client";
+export { Config as IkasAPIClientConfig };

package/build/__api/models/AbandonedCartFlow.d.ts

@@ -1,19 +0,0 @@
-import { DeepReadonly } from "ts-essentials";
-import { CheckoutRecoveryEmailStatusEnum } from "../types";
-import { AbandonedCartFlowCustomerFilterData } from "./AbandonedCartFlowCustomerFilter";
-export declare 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>);
-}
-export declare class AbandonedCartFlow extends AbandonedCartFlowData {
-}
-export declare type PartialAbandonedCartFlow = Partial<AbandonedCartFlow>;
-export declare type ReadOnlyAbandonedCartFlow = DeepReadonly<AbandonedCartFlow>;

package/build/__api/models/AbandonedCartFlowCustomerFilter.d.ts

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

package/build/__api/models/AddItemToCartInput.d.ts

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

package/build/__api/models/AdditionalPrice.d.ts

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

package/build/__api/models/ApplicableProductFilterValue.d.ts

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

package/build/__api/models/AppliedProduct.d.ts

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

package/build/__api/models/AppliedProductInput.d.ts

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

package/build/__api/models/AvailableShippingMethod.d.ts

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

package/build/__api/models/Blog.d.ts

@@ -1,28 +0,0 @@
-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 declare 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>);
-}
-export declare class Blog extends BlogData {
-}
-export declare type PartialBlog = Partial<Blog>;
-export declare type ReadOnlyBlog = DeepReadonly<Blog>;