@ikas/storefront-api 4.0.0-alpha.48 → 4.0.0-alpha.49

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

@@ -0,0 +1,18 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { OrderPackageFulfillStatusEnum } from "../types";
+import { TrackingInfoData } from "./TrackingInfo";
+export declare 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>);
+}
+export declare class OrderPackage extends OrderPackageData {
+}
+export declare type PartialOrderPackage = Partial<OrderPackage>;
+export declare type ReadOnlyOrderPackage = DeepReadonly<OrderPackage>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+import { DeepReadonly } from "ts-essentials";
+import { OrderSessionInfoTrafficSourceData } from "./OrderSessionInfoTrafficSource";
+import { OrderSessionUserAgentData } from "./OrderSessionUserAgent";
+import { OrderSessionUTMData } from "./OrderSessionUTM";
+export declare class OrderSessionInfoData {
+    countryCode: string | null;
+    durationMS: number | null;
+    end: any | null;
+    host: string | null;
+    ip: string | null;
+    referer: string | null;
+    salesChannelId: string | null;
+    sessionId: string | null;
+    start: any | null;
+    storefrontId: string | null;
+    trafficSource: OrderSessionInfoTrafficSourceData | null;
+    userAgent: OrderSessionUserAgentData | null;
+    utm: OrderSessionUTMData | null;
+    visitorId: string | null;
+    constructor(data?: Partial<OrderSessionInfoData>);
+}
+export declare class OrderSessionInfo extends OrderSessionInfoData {
+}
+export declare type PartialOrderSessionInfo = Partial<OrderSessionInfo>;
+export declare type ReadOnlyOrderSessionInfo = DeepReadonly<OrderSessionInfo>;

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

@@ -0,0 +1,11 @@
+import { DeepReadonly } from "ts-essentials";
+import { SFAnalyticsTrafficSourceEnum } from "../types";
+export declare class OrderSessionInfoTrafficSourceData {
+    source: string | null;
+    type: SFAnalyticsTrafficSourceEnum;
+    constructor(data?: Partial<OrderSessionInfoTrafficSourceData>);
+}
+export declare class OrderSessionInfoTrafficSource extends OrderSessionInfoTrafficSourceData {
+}
+export declare type PartialOrderSessionInfoTrafficSource = Partial<OrderSessionInfoTrafficSource>;
+export declare type ReadOnlyOrderSessionInfoTrafficSource = DeepReadonly<OrderSessionInfoTrafficSource>;

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

@@ -0,0 +1,13 @@
+import { DeepReadonly } from "ts-essentials";
+export declare class OrderSessionUTMData {
+    campaign: string | null;
+    content: string | null;
+    medium: string | null;
+    source: string | null;
+    term: string | null;
+    constructor(data?: Partial<OrderSessionUTMData>);
+}
+export declare class OrderSessionUTM extends OrderSessionUTMData {
+}
+export declare type PartialOrderSessionUTM = Partial<OrderSessionUTM>;
+export declare type ReadOnlyOrderSessionUTM = DeepReadonly<OrderSessionUTM>;

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

@@ -0,0 +1,12 @@
+import { DeepReadonly } from "ts-essentials";
+import { UserAgentDeviceType } from "../types";
+export declare class OrderSessionUserAgentData {
+    deviceType: UserAgentDeviceType;
+    name: string;
+    os: string;
+    constructor(data?: Partial<OrderSessionUserAgentData>);
+}
+export declare class OrderSessionUserAgent extends OrderSessionUserAgentData {
+}
+export declare type PartialOrderSessionUserAgent = Partial<OrderSessionUserAgent>;
+export declare type ReadOnlyOrderSessionUserAgent = DeepReadonly<OrderSessionUserAgent>;

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

@@ -0,0 +1,17 @@
+import { DeepReadonly } from "ts-essentials";
+import { PaymentMethodTypeEnum } from "../types";
+export declare 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>);
+}
+export declare class OrderShippingLine extends OrderShippingLineData {
+}
+export declare type PartialOrderShippingLine = Partial<OrderShippingLine>;
+export declare type ReadOnlyOrderShippingLine = DeepReadonly<OrderShippingLine>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+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 declare 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>);
+}
+export declare class PaymentGateway extends PaymentGatewayData {
+}
+export declare type PartialPaymentGateway = Partial<PaymentGateway>;
+export declare type ReadOnlyPaymentGateway = DeepReadonly<PaymentGateway>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { ProductTypeEnum } from "../types";
+import { ProductAttributeValueData } from "./ProductAttributeValue";
+import { ProductBaseUnitModelData } from "./ProductBaseUnitModel";
+import { HTMLMetaDataData } from "./HTMLMetaData";
+import { ProductVariantTypeData } from "./ProductVariantType";
+import { ProductTranslationData } from "./ProductTranslation";
+import { VariantData } from "./Variant";
+export declare class ProductData extends BaseModelData {
+    attributes: ProductAttributeValueData[] | null;
+    baseUnit: ProductBaseUnitModelData | 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>);
+}
+export declare class Product extends ProductData {
+}
+export declare type PartialProduct = Partial<Product>;
+export declare type ReadOnlyProduct = DeepReadonly<Product>;

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

@@ -0,0 +1,19 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { ProductAttributeTypeEnum } from "../types";
+import { ProductAttributeOptionData } from "./ProductAttributeOption";
+import { ProductAttributeTableTemplateData } from "./ProductAttributeTableTemplate";
+import { ProductAttributeTranslationData } from "./ProductAttributeTranslation";
+export declare class ProductAttributeData extends BaseModelData {
+    description: string | null;
+    name: string;
+    options: ProductAttributeOptionData[] | null;
+    tableTemplate: ProductAttributeTableTemplateData | null;
+    translations: ProductAttributeTranslationData[] | null;
+    type: ProductAttributeTypeEnum;
+    constructor(data?: Partial<ProductAttributeData>);
+}
+export declare class ProductAttribute extends ProductAttributeData {
+}
+export declare type PartialProductAttribute = Partial<ProductAttribute>;
+export declare type ReadOnlyProductAttribute = DeepReadonly<ProductAttribute>;

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

@@ -0,0 +1,10 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+export declare class ProductAttributeOptionData extends BaseModelData {
+    name: string;
+    constructor(data?: Partial<ProductAttributeOptionData>);
+}
+export declare class ProductAttributeOption extends ProductAttributeOptionData {
+}
+export declare type PartialProductAttributeOption = Partial<ProductAttributeOption>;
+export declare type ReadOnlyProductAttributeOption = DeepReadonly<ProductAttributeOption>;

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

@@ -0,0 +1,10 @@
+import { DeepReadonly } from "ts-essentials";
+export declare class ProductAttributeOptionTranslationData {
+    id: string;
+    name: string | null;
+    constructor(data?: Partial<ProductAttributeOptionTranslationData>);
+}
+export declare class ProductAttributeOptionTranslation extends ProductAttributeOptionTranslationData {
+}
+export declare type PartialProductAttributeOptionTranslation = Partial<ProductAttributeOptionTranslation>;
+export declare type ReadOnlyProductAttributeOptionTranslation = DeepReadonly<ProductAttributeOptionTranslation>;

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

@@ -0,0 +1,10 @@
+import { DeepReadonly } from "ts-essentials";
+export declare class ProductAttributeTableCellDataData {
+    id: string;
+    name: string;
+    constructor(data?: Partial<ProductAttributeTableCellDataData>);
+}
+export declare class ProductAttributeTableCellData extends ProductAttributeTableCellDataData {
+}
+export declare type PartialProductAttributeTableCellData = Partial<ProductAttributeTableCellData>;
+export declare type ReadOnlyProductAttributeTableCellData = DeepReadonly<ProductAttributeTableCellData>;

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

@@ -0,0 +1,11 @@
+import { DeepReadonly } from "ts-essentials";
+import { ProductAttributeTableCellDataData } from "./ProductAttributeTableCellData";
+export declare class ProductAttributeTableTemplateData {
+    columns: ProductAttributeTableCellDataData[];
+    rows: ProductAttributeTableCellDataData[];
+    constructor(data?: Partial<ProductAttributeTableTemplateData>);
+}
+export declare class ProductAttributeTableTemplate extends ProductAttributeTableTemplateData {
+}
+export declare type PartialProductAttributeTableTemplate = Partial<ProductAttributeTableTemplate>;
+export declare type ReadOnlyProductAttributeTableTemplate = DeepReadonly<ProductAttributeTableTemplate>;

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

@@ -0,0 +1,13 @@
+import { DeepReadonly } from "ts-essentials";
+import { ProductAttributeOptionTranslationData } from "./ProductAttributeOptionTranslation";
+export declare class ProductAttributeTranslationData {
+    description: string | null;
+    locale: string;
+    name: string | null;
+    options: ProductAttributeOptionTranslationData[] | null;
+    constructor(data?: Partial<ProductAttributeTranslationData>);
+}
+export declare class ProductAttributeTranslation extends ProductAttributeTranslationData {
+}
+export declare type PartialProductAttributeTranslation = Partial<ProductAttributeTranslation>;
+export declare type ReadOnlyProductAttributeTranslation = DeepReadonly<ProductAttributeTranslation>;

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

@@ -0,0 +1,12 @@
+import { DeepReadonly } from "ts-essentials";
+export declare class ProductAttributeValueData {
+    imageIds: string[] | null;
+    productAttributeId: string | null;
+    productAttributeOptionId: string | null;
+    value: string | null;
+    constructor(data?: Partial<ProductAttributeValueData>);
+}
+export declare class ProductAttributeValue extends ProductAttributeValueData {
+}
+export declare type PartialProductAttributeValue = Partial<ProductAttributeValue>;
+export declare type ReadOnlyProductAttributeValue = DeepReadonly<ProductAttributeValue>;

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

@@ -0,0 +1,15 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+export declare class ProductBackInStockRemindData extends BaseModelData {
+    customerId: string;
+    email: string;
+    productId: string;
+    storefrontId: string;
+    storefrontRoutingId: string | null;
+    variantId: string;
+    constructor(data?: Partial<ProductBackInStockRemindData>);
+}
+export declare class ProductBackInStockRemind extends ProductBackInStockRemindData {
+}
+export declare type PartialProductBackInStockRemind = Partial<ProductBackInStockRemind>;
+export declare type ReadOnlyProductBackInStockRemind = DeepReadonly<ProductBackInStockRemind>;

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

@@ -0,0 +1,11 @@
+import { DeepReadonly } from "ts-essentials";
+export declare class ProductBackInStockRemindInputData {
+    email: string;
+    productId: string;
+    variantId: string;
+    constructor(data?: Partial<ProductBackInStockRemindInputData>);
+}
+export declare class ProductBackInStockRemindInput extends ProductBackInStockRemindInputData {
+}
+export declare type PartialProductBackInStockRemindInput = Partial<ProductBackInStockRemindInput>;
+export declare type ReadOnlyProductBackInStockRemindInput = DeepReadonly<ProductBackInStockRemindInput>;

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

@@ -0,0 +1,12 @@
+import { DeepReadonly } from "ts-essentials";
+import { ProductUnitTypeEnum } from "../types";
+export declare class ProductBaseUnitModelData {
+    baseAmount: number | null;
+    type: ProductUnitTypeEnum;
+    unitId: string | null;
+    constructor(data?: Partial<ProductBaseUnitModelData>);
+}
+export declare class ProductBaseUnitModel extends ProductBaseUnitModelData {
+}
+export declare type PartialProductBaseUnitModel = Partial<ProductBaseUnitModel>;
+export declare type ReadOnlyProductBaseUnitModel = DeepReadonly<ProductBaseUnitModel>;

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

@@ -0,0 +1,19 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+import { CategoryProductsOrderTypeEnum } from "../types";
+import { HTMLMetaDataData } from "./HTMLMetaData";
+import { ProductBrandTranslationData } from "./ProductBrandTranslation";
+export declare class ProductBrandData extends BaseModelData {
+    description: string | null;
+    imageId: string | null;
+    metaData: HTMLMetaDataData | null;
+    name: string;
+    orderType: CategoryProductsOrderTypeEnum | null;
+    salesChannelIds: string[] | null;
+    translations: ProductBrandTranslationData[] | null;
+    constructor(data?: Partial<ProductBrandData>);
+}
+export declare class ProductBrand extends ProductBrandData {
+}
+export declare type PartialProductBrand = Partial<ProductBrand>;
+export declare type ReadOnlyProductBrand = DeepReadonly<ProductBrand>;

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

@@ -0,0 +1,14 @@
+import { DeepReadonly } from "ts-essentials";
+import { ProductBrandData } from "./ProductBrand";
+export declare class ProductBrandPaginationResponseData {
+    count: number;
+    data: ProductBrandData[];
+    hasNext: boolean;
+    limit: number;
+    page: number;
+    constructor(data?: Partial<ProductBrandPaginationResponseData>);
+}
+export declare class ProductBrandPaginationResponse extends ProductBrandPaginationResponseData {
+}
+export declare type PartialProductBrandPaginationResponse = Partial<ProductBrandPaginationResponse>;
+export declare type ReadOnlyProductBrandPaginationResponse = DeepReadonly<ProductBrandPaginationResponse>;

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

@@ -0,0 +1,11 @@
+import { DeepReadonly } from "ts-essentials";
+export declare class ProductBrandTranslationData {
+    description: string | null;
+    locale: string;
+    name: string | null;
+    constructor(data?: Partial<ProductBrandTranslationData>);
+}
+export declare class ProductBrandTranslation extends ProductBrandTranslationData {
+}
+export declare type PartialProductBrandTranslation = Partial<ProductBrandTranslation>;
+export declare type ReadOnlyProductBrandTranslation = DeepReadonly<ProductBrandTranslation>;

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

@@ -0,0 +1,11 @@
+import { DeepReadonly } from "ts-essentials";
+import { ProductFacetCountValueData } from "./ProductFacetCountValue";
+export declare class ProductFacetCountData {
+    id: string;
+    values: ProductFacetCountValueData[];
+    constructor(data?: Partial<ProductFacetCountData>);
+}
+export declare class ProductFacetCount extends ProductFacetCountData {
+}
+export declare type PartialProductFacetCount = Partial<ProductFacetCount>;
+export declare type ReadOnlyProductFacetCount = DeepReadonly<ProductFacetCount>;

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

@@ -0,0 +1,10 @@
+import { DeepReadonly } from "ts-essentials";
+export declare class ProductFacetCountValueData {
+    count: number;
+    id: string;
+    constructor(data?: Partial<ProductFacetCountValueData>);
+}
+export declare class ProductFacetCountValue extends ProductFacetCountValueData {
+}
+export declare type PartialProductFacetCountValue = Partial<ProductFacetCountValue>;
+export declare type ReadOnlyProductFacetCountValue = DeepReadonly<ProductFacetCountValue>;

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

@@ -0,0 +1,12 @@
+import { DeepReadonly } from "ts-essentials";
+import { CategoryData } from "./Category";
+import { ProductFilterDataFilterData } from "./ProductFilterDataFilter";
+export declare class ProductFilterDataData {
+    categories: CategoryData[] | null;
+    filters: ProductFilterDataFilterData[];
+    constructor(data?: Partial<ProductFilterDataData>);
+}
+export declare class ProductFilterData extends ProductFilterDataData {
+}
+export declare type PartialProductFilterData = Partial<ProductFilterData>;
+export declare type ReadOnlyProductFilterData = DeepReadonly<ProductFilterData>;

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

@@ -0,0 +1,24 @@
+import { DeepReadonly } from "ts-essentials";
+import { ProductFilterDisplayTypeEnum, ProductFilterTypeEnum } from "../types";
+import { CategoryData } from "./Category";
+import { ProductFilterSettingsData } from "./ProductFilterSettings";
+import { ApplicableProductFilterValueData } from "./ApplicableProductFilterValue";
+export declare class ProductFilterDataFilterData {
+    categories: CategoryData[] | null;
+    customValues: string[] | null;
+    displayType: ProductFilterDisplayTypeEnum;
+    id: string;
+    isFacetFilter: boolean | null;
+    isMultiSelect: boolean;
+    key: string;
+    name: string;
+    order: number;
+    settings: ProductFilterSettingsData | null;
+    type: ProductFilterTypeEnum;
+    values: ApplicableProductFilterValueData[] | null;
+    constructor(data?: Partial<ProductFilterDataFilterData>);
+}
+export declare class ProductFilterDataFilter extends ProductFilterDataFilterData {
+}
+export declare type PartialProductFilterDataFilter = Partial<ProductFilterDataFilter>;
+export declare type ReadOnlyProductFilterDataFilter = DeepReadonly<ProductFilterDataFilter>;

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

@@ -0,0 +1,14 @@
+import { DeepReadonly } from "ts-essentials";
+import { ProductFilterSortTypeEnum } from "../types";
+export declare class ProductFilterSettingsData {
+    customSortedValues: string[] | null;
+    showCollapsedOnDesktop: boolean;
+    showCollapsedOnMobile: boolean;
+    sortType: ProductFilterSortTypeEnum;
+    useAndFilter: boolean | null;
+    constructor(data?: Partial<ProductFilterSettingsData>);
+}
+export declare class ProductFilterSettings extends ProductFilterSettingsData {
+}
+export declare type PartialProductFilterSettings = Partial<ProductFilterSettings>;
+export declare type ReadOnlyProductFilterSettings = DeepReadonly<ProductFilterSettings>;

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

@@ -0,0 +1,12 @@
+import { DeepReadonly } from "ts-essentials";
+export declare class ProductImageData {
+    imageId: string | null;
+    isMain: boolean;
+    isVideo: boolean | null;
+    order: number;
+    constructor(data?: Partial<ProductImageData>);
+}
+export declare class ProductImage extends ProductImageData {
+}
+export declare type PartialProductImage = Partial<ProductImage>;
+export declare type ReadOnlyProductImage = DeepReadonly<ProductImage>;

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

@@ -0,0 +1,11 @@
+import { DeepReadonly } from "ts-essentials";
+import BaseModelData from "./_base";
+export declare class ProductItemData extends BaseModelData {
+    productId: string;
+    variantId: string;
+    constructor(data?: Partial<ProductItemData>);
+}
+export declare class ProductItem extends ProductItemData {
+}
+export declare type PartialProductItem = Partial<ProductItem>;
+export declare type ReadOnlyProductItem = DeepReadonly<ProductItem>;