@devite/shopware-client 1.8.0 → 1.9.1

package/dist/types/api/admin/order/Order.d.ts

@@ -4,7 +4,6 @@ import { StateMachineState } from "../stateMachine/StateMachineState";
 import { OrderCustomer } from "./OrderCustomer";
 import { Currency } from "../currency/Currency";
 import { Language } from "../locale/Language";
-import { SalesChannel } from "../salesChannel/SalesChannel";
 import { OrderAddress } from "./OrderAddress";
 import { OrderDelivery } from "./delivery/OrderDelivery";
 import { OrderLineItem } from "./lineItem/OrderLineItem";
@@ -12,23 +11,23 @@ import { OrderTransaction } from "./transaction/OrderTransaction";
 import { ShopwareDocument } from "../document/ShopwareDocument";
 import { Tag } from "../Tag";
 import { User } from "../user/User";
-export type Order = StoreApiOrder & {
-    readonly autoIncrement: number;
+export type Order = Omit<StoreApiOrder, "currency" | "lineItems" | "stateMachineState" | "addresses" | "billingAddress" | "orderCustomer" | "deliveries" | "transactions" | "documents" | "language" | "tags"> & {
+    readonly createdAt: string;
+    createdBy?: User;
+    readonly updatedAt?: string;
+    updatedBy?: User;
+    internalComment?: string;
     itemRounding: Rounding;
     totalRounding: Rounding;
-    stateMachineState?: StateMachineState;
-    orderCustomer?: OrderCustomer;
     currency?: Currency;
-    language?: Language;
-    salesChannel?: SalesChannel;
+    lineItems?: Array<OrderLineItem>;
+    stateMachineState?: StateMachineState;
     addresses?: Array<OrderAddress>;
     billingAddress?: OrderAddress;
+    orderCustomer?: OrderCustomer;
     deliveries?: Array<OrderDelivery>;
-    lineItems?: Array<OrderLineItem>;
     transactions?: Array<OrderTransaction>;
     documents?: Array<ShopwareDocument>;
+    language?: Language;
     tags?: Array<Tag>;
-    createdBy?: User;
-    updatedBy?: User;
-    internalComment?: string;
 };

package/dist/types/api/admin/order/OrderAddress.d.ts

@@ -1,15 +1,9 @@
 import { OrderAddress as StoreApiOrderAddress } from "#types/api/store/order/OrderAddress";
 import { Country } from "../country/Country";
 import { CountryState } from "../country/CountryState";
-import { Order } from "./Order";
-import { OrderDelivery } from "./delivery/OrderDelivery";
 import { Salutation } from "../Salutation";
-export type OrderAddress = StoreApiOrderAddress & {
-    orderId?: string;
-    orderVersionId?: string;
+export type OrderAddress = Omit<StoreApiOrderAddress, "salutation" | "country" | "countryState"> & {
+    salutation: Salutation;
     country?: Country;
     countryState?: CountryState;
-    order?: Order;
-    orderDeliveries?: Array<OrderDelivery>;
-    salutation: Salutation;
 };

package/dist/types/api/admin/order/OrderCustomer.d.ts

@@ -1,13 +1,9 @@
 import { OrderCustomer as StoreApiOrderCustomer } from "#types/api/store/order/OrderCustomer";
-import { Order } from "./Order";
 import { Customer } from "../customer/Customer";
 import { Salutation } from "../Salutation";
-export type OrderCustomer = StoreApiOrderCustomer & {
-    customerId?: string;
-    orderId: string;
-    orderVersionId?: string;
+export type OrderCustomer = Omit<StoreApiOrderCustomer, "salutation"> & {
     remoteAddress?: string;
-    order?: Order;
-    customer?: Customer;
     salutation: Salutation;
+    customerId?: string;
+    customer?: Customer;
 };

package/dist/types/api/admin/order/delivery/OrderDelivery.d.ts

@@ -1,13 +1,11 @@
 import { OrderDelivery as StoreApiOrderDelivery } from "#types/api/store/order/delivery/OrderDelivery";
 import { GenericRecord } from "#types/api/global/GenericRecord";
 import { StateMachineState } from "#types/api/store";
-import { Order } from "../Order";
 import { OrderAddress } from "../OrderAddress";
 import { OrderDeliveryPosition } from "./OrderDeliveryPosition";
-export type OrderDelivery = StoreApiOrderDelivery & {
-    customFields?: GenericRecord;
-    stateMachineState?: StateMachineState;
-    order: Order;
+export type OrderDelivery = Omit<StoreApiOrderDelivery, "shippingOrderAddress" | "stateMachineState" | "positions"> & {
     shippingOrderAddress?: OrderAddress;
+    stateMachineState?: StateMachineState;
     positions?: Array<OrderDeliveryPosition>;
+    customFields?: GenericRecord;
 };

package/dist/types/api/admin/order/delivery/OrderDeliveryPosition.d.ts

@@ -1,7 +1,5 @@
 import { OrderDeliveryPosition as StoreApiOrderDeliveryPosition } from "#types/api/store/order/delivery/OrderDeliveryPosition";
-import { OrderDelivery } from "./OrderDelivery";
 import { OrderLineItem } from "../lineItem/OrderLineItem";
-export type OrderDeliveryPosition = StoreApiOrderDeliveryPosition & {
-    orderDelivery?: OrderDelivery;
+export type OrderDeliveryPosition = Omit<StoreApiOrderDeliveryPosition, "orderLineItem"> & {
     orderLineItem?: OrderLineItem;
 };

package/dist/types/api/admin/order/index.d.ts

@@ -1,9 +1,6 @@
 export * from "./delivery";
 export * from "./lineItem";
-export * from "./return";
 export * from "./transaction";
-export * from "./warehouse";
 export { Order } from "./Order";
 export { OrderAddress } from "./OrderAddress";
 export { OrderCustomer } from "./OrderCustomer";
-export { OrderTag } from "./OrderTag";

package/dist/types/api/admin/order/lineItem/OrderLineItem.d.ts

@@ -1,13 +1,9 @@
 import { OrderLineItem as StoreApiOrderLineItem } from "#types/api/store/order/OrderLineItem";
 import { Media } from "../../media/Media";
-import { OrderDeliveryPosition } from "../delivery/OrderDeliveryPosition";
-import { OrderTransactionCaptureRefundPosition } from "../transaction/capture/OrderTransactionCaptureRefundPosition";
 import { OrderLineItemDownload } from "./OrderLineItemDownload";
-export type OrderLineItem = StoreApiOrderLineItem & {
-    cover?: Media;
-    orderDeliveryPositions?: Array<OrderDeliveryPosition>;
-    orderTransactionCaptureRefundPositions?: Array<OrderTransactionCaptureRefundPosition>;
-    downloads?: Array<OrderLineItemDownload>;
+export type OrderLineItem = Omit<StoreApiOrderLineItem, "parent" | "children" | "cover" | "downloads"> & {
     parent?: OrderLineItem;
     children: Array<OrderLineItem>;
+    cover?: Media;
+    downloads?: Array<OrderLineItemDownload>;
 };

package/dist/types/api/admin/order/lineItem/OrderLineItemDownload.d.ts

@@ -1,7 +1,7 @@
 import { OrderLineItemDownload as StoreApiOrderLineItemDownload } from "#types/api/store/order/OrderLineItemDownload";
 import { OrderLineItem } from "./OrderLineItem";
 import { Media } from "../../media/Media";
-export type OrderLineItemDownload = StoreApiOrderLineItemDownload & {
+export type OrderLineItemDownload = Omit<StoreApiOrderLineItemDownload, "orderLineItem" | "media"> & {
     orderLineItem?: OrderLineItem;
     media?: Media;
 };

package/dist/types/api/admin/order/transaction/OrderTransaction.d.ts

@@ -2,7 +2,7 @@ import { OrderTransaction as StoreApiOrderTransaction } from "#types/api/store/o
 import { StateMachineState } from "../../stateMachine/StateMachineState";
 import { Order } from "../Order";
 import { OrderTransactionCapture } from "./capture/OrderTransactionCapture";
-export type OrderTransaction = StoreApiOrderTransaction & {
+export type OrderTransaction = Omit<StoreApiOrderTransaction, "stateMachineState" | "captures"> & {
     stateMachineState?: StateMachineState;
     order?: Order;
     captures?: Array<OrderTransactionCapture>;

package/dist/types/api/admin/order/transaction/capture/OrderTransactionCapture.d.ts

@@ -1,9 +1,9 @@
-import { OrderTransactionCapture as StoreApiOrderTransactionCapture } from "#types/api/store/order/transaction/OrderTransactionCapture";
+import { OrderTransactionCapture as StoreApiOrderTransactionCapture } from "#types/api/store/order/transaction/capture/OrderTransactionCapture";
 import { StateMachineState } from "../../../stateMachine/StateMachineState";
 import { OrderTransaction } from "../OrderTransaction";
 import { OrderTransactionCaptureRefund } from "./OrderTransactionCaptureRefund";
-export type OrderTransactionCapture = StoreApiOrderTransactionCapture & {
+export type OrderTransactionCapture = Omit<StoreApiOrderTransactionCapture, "stateMachineState" | "refunds" | "transaction"> & {
     stateMachineState?: StateMachineState;
-    transaction?: OrderTransaction;
     refunds?: Array<OrderTransactionCaptureRefund>;
+    transaction?: OrderTransaction;
 };

package/dist/types/api/admin/order/transaction/capture/OrderTransactionCaptureRefund.d.ts

@@ -1,8 +1,8 @@
-import { OrderTransactionCaptureRefund as StoreApiOrderTransactionCaptureRefund } from "#types/api/store/order/transaction/OrderTransactionCaptureRefund";
+import { OrderTransactionCaptureRefund as StoreApiOrderTransactionCaptureRefund } from "#types/api/store/order/transaction/capture/OrderTransactionCaptureRefund";
 import { StateMachineState } from "../../../stateMachine/StateMachineState";
 import { OrderTransactionCapture } from "./OrderTransactionCapture";
 import { OrderTransactionCaptureRefundPosition } from "./OrderTransactionCaptureRefundPosition";
-export type OrderTransactionCaptureRefund = StoreApiOrderTransactionCaptureRefund & {
+export type OrderTransactionCaptureRefund = Omit<StoreApiOrderTransactionCaptureRefund, "stateMachineState" | "transactionCapture" | "positions"> & {
     stateMachineState?: StateMachineState;
     transactionCapture?: OrderTransactionCapture;
     positions?: Array<OrderTransactionCaptureRefundPosition>;

package/dist/types/api/admin/order/transaction/capture/OrderTransactionCaptureRefundPosition.d.ts

@@ -1,7 +1,7 @@
-import { OrderTransactionCaptureRefundPosition as StoreApiOrderTransactionCaptureRefundPosition } from "#types/api/store/order/transaction/OrderTransactionCaptureRefundPosition";
+import { OrderTransactionCaptureRefundPosition as StoreApiOrderTransactionCaptureRefundPosition } from "#types/api/store/order/transaction/capture/OrderTransactionCaptureRefundPosition";
 import { OrderLineItem } from "../../lineItem/OrderLineItem";
 import { OrderTransactionCaptureRefund } from "./OrderTransactionCaptureRefund";
-export type OrderTransactionCaptureRefundPosition = StoreApiOrderTransactionCaptureRefundPosition & {
-    orderLineItem?: OrderLineItem;
+export type OrderTransactionCaptureRefundPosition = Omit<StoreApiOrderTransactionCaptureRefundPosition, "orderTransactionCaptureRefund" | "orderLineItem"> & {
     orderTransactionCaptureRefund?: OrderTransactionCaptureRefund;
+    orderLineItem?: OrderLineItem;
 };

package/dist/types/api/admin/paymentMethod/PaymentMethod.d.ts

@@ -1,22 +1,10 @@
 import { PaymentMethod as StoreApiPaymentMethod } from "#types/api/store/PaymentMethod";
 import { Media } from "../media/Media";
 import { Rule } from "../rule/Rule";
-import { SalesChannel } from "../salesChannel/SalesChannel";
-import { ShopwarePlugin } from "../ShopwarePlugin";
-import { Customer } from "../customer/Customer";
-import { OrderTransaction } from "../order/transaction/OrderTransaction";
-import { AppPaymentMethod } from "./AppPaymentMethod";
-export type PaymentMethod = StoreApiPaymentMethod & {
-    pluginId?: string;
+export type PaymentMethod = Omit<StoreApiPaymentMethod, "media"> & {
     handlerIdentifier?: string;
-    availabilityRuleId?: string;
     readonly formattedHandlerIdentifier?: string;
-    media?: Media;
+    availabilityRuleId?: string;
     availabilityRule?: Rule;
-    salesChannelDefaultAssignments?: Array<SalesChannel>;
-    plugin?: ShopwarePlugin;
-    customers?: Array<Customer>;
-    orderTransactions?: Array<OrderTransaction>;
-    salesChannels?: Array<SalesChannel>;
-    appPaymentMethod?: AppPaymentMethod;
+    media?: Media;
 };

package/dist/types/api/admin/paymentMethod/index.d.ts

@@ -1,2 +1 @@
-export { AppPaymentMethod } from "./AppPaymentMethod";
 export { PaymentMethod } from "./PaymentMethod";

package/dist/types/api/admin/product/Product.d.ts

@@ -1,65 +1,45 @@
+import { CalculatedPrice } from "#types/api/store/price/CalculatedPrice";
+import { Category } from "../category/Category";
+import { CmsPage } from "../cms/CmsPage";
+import { DeliveryTime } from "../DeliveryTime";
+import { MainCategory } from "../category/MainCategory";
+import { Price } from "#types/api/global";
 import { Product as StoreApiProduct } from "#types/api/store/product/Product";
+import { ProductCrossSelling } from "./crossSelling/ProductCrossSelling";
 import { ProductDownload } from "./ProductDownload";
-import { DeliveryTime } from "../DeliveryTime";
-import { Tax } from "../tax/Tax";
 import { ProductManufacturer } from "./ProductManufacturer";
-import { Unit } from "../Unit";
 import { ProductMedia } from "./ProductMedia";
-import { ProductFeatureSet } from "./ProductFeatureSet";
-import { CmsPage } from "../cms/CmsPage";
-import { ProductCrossSelling } from "./crossSelling/ProductCrossSelling";
-import { ProductCrossSellingAssignedProduct } from "./crossSelling/ProductCrossSellingAssignedProduct";
-import { ProductConfiguratorSetting } from "./ProductConfiguratorSetting";
-import { ProductVisibility } from "./ProductVisibility";
+import { ProductReview } from "./ProductReview";
 import { ProductSearchKeyword } from "./search/ProductSearchKeyword";
-import { ProductReview } from "./review/ProductReview";
-import { MainCategory } from "../category/MainCategory";
-import { SeoUrl } from "../seo/SeoUrl";
-import { OrderLineItem } from "../order/lineItem/OrderLineItem";
-import { CustomerWishlist } from "../customer/wishlist/CustomerWishlist";
-import { PropertyGroupOption } from "../propertyGroup/PropertyGroupOption";
-import { Category } from "../category/Category";
 import { ProductStream } from "./stream/ProductStream";
+import { PropertyGroupOption } from "../propertyGroup/PropertyGroupOption";
+import { SeoUrl } from "../seo/SeoUrl";
 import { Tag } from "../Tag";
-import { CustomFieldSet } from "../custom/field/set/CustomFieldSet";
-import { CalculatedPrice } from "#types/api/store/price/CalculatedPrice";
-import { Price } from "#types/api/global";
-export type Product = StoreApiProduct & {
-    featureSetId?: string;
-    price?: Array<Price>;
+export type Product = Omit<StoreApiProduct, "children" | "deliveryTime" | "cover" | "media" | "tags" | "properties" | "options" | "streams" | "productReviews" | "crossSellings" | "categories" | "mainCategories" | "seoUrls" | "seoCategory" | "downloads" | "cmsPage"> & {
     readonly autoIncrement?: number;
-    variantRestrictions?: object;
-    purchasePrices?: Array<CalculatedPrice>;
-    customFieldSetSelectionActive?: boolean;
-    slotConfig?: object;
-    customSearchKeywords?: Array<object>;
-    downloads?: Array<ProductDownload>;
-    parent?: Product;
     children?: Array<Product>;
-    deliveryTime?: DeliveryTime;
-    tax?: Tax;
+    manufacturerId?: string;
+    productManufacturerVersionId?: string;
     manufacturer?: ProductManufacturer;
-    unit?: Unit;
+    manufacturerNumber?: string;
+    deliveryTime?: DeliveryTime;
     cover?: ProductMedia;
-    featureSet?: ProductFeatureSet;
-    cmsPage?: CmsPage;
-    canonicalProduct?: Product;
     media?: Array<ProductMedia>;
-    crossSellings?: Array<ProductCrossSelling>;
-    crossSellingAssignedProducts?: Array<ProductCrossSellingAssignedProduct>;
-    configuratorSettings?: Array<ProductConfiguratorSetting>;
-    visibilities?: Array<ProductVisibility>;
+    tags?: Array<Tag>;
     searchKeywords?: Array<ProductSearchKeyword>;
-    productReviews?: Array<ProductReview>;
-    mainCategories?: Array<MainCategory>;
-    seoUrls?: Array<SeoUrl>;
-    orderLineItems?: Array<OrderLineItem>;
-    wishlists?: Array<CustomerWishlist>;
-    options?: Array<PropertyGroupOption>;
+    customSearchKeywords?: Array<string>;
     properties?: Array<PropertyGroupOption>;
-    categories?: Array<Category>;
+    options?: Array<PropertyGroupOption>;
     streams?: Array<ProductStream>;
+    productReviews?: Array<ProductReview>;
+    crossSellings?: Array<ProductCrossSelling>;
+    categories?: Array<Category>;
     categoriesRo?: Array<Category>;
-    tags?: Array<Tag>;
-    customFieldSets?: Array<CustomFieldSet>;
+    mainCategories?: Array<MainCategory>;
+    seoUrls?: Array<SeoUrl>;
+    seoCategory: Category;
+    price?: Array<Price>;
+    purchasePrices?: Array<CalculatedPrice>;
+    downloads?: Array<ProductDownload>;
+    cmsPage?: CmsPage;
 };

package/dist/types/api/admin/product/ProductDownload.d.ts

@@ -2,16 +2,16 @@ import { ProductDownload as StoreApiProductDownload } from "#types/api/store/pro
 import { GenericRecord } from "#types/api/global/GenericRecord";
 import { Product } from "./Product";
 import { Media } from "../media/Media";
-export type ProductDownload = StoreApiProductDownload & {
+export type ProductDownload = Omit<StoreApiProductDownload, "product" | "media"> & {
     id: string;
     versionId?: string;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
+    position?: number;
     productId: string;
     productVersionId?: string;
-    mediaId: string;
-    position?: number;
-    customFields?: GenericRecord;
-    readonly createdAt?: string;
-    readonly updatedAt?: string;
     product?: Product;
+    mediaId: string;
     media?: Media;
+    customFields?: GenericRecord;
 };

package/dist/types/api/admin/product/ProductManufacturer.d.ts

@@ -1,7 +1,15 @@
-import { ProductManufacturer as StoreApiProductManufacturer } from "#types/api/store/product/ProductManufacturer";
+import { GenericRecord } from "#types/api/global/GenericRecord";
 import { Media } from "../media/Media";
-import { Product } from "./Product";
-export type ProductManufacturer = StoreApiProductManufacturer & {
+export type ProductManufacturer = {
+    id: string;
+    versionId?: string;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
+    link?: string;
+    name: string;
+    description?: string;
+    mediaId?: string;
     media?: Media;
-    products?: Array<Product>;
+    customFields?: GenericRecord;
+    translated?: Record<string, any>;
 };

package/dist/types/api/admin/product/ProductMedia.d.ts

@@ -1,17 +1,12 @@
 import { GenericRecord } from "#types/api/global/GenericRecord";
-import { Product } from "./Product";
 import { Media } from "../media/Media";
 export interface ProductMedia {
     id: string;
     versionId?: string;
-    productId: string;
-    productVersionId?: string;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
     mediaId: string;
+    media?: Media;
     position?: number;
     customFields?: GenericRecord;
-    readonly createdAt?: string;
-    readonly updatedAt?: string;
-    product?: Product;
-    media?: Media;
-    coverProducts?: Array<Product>;
 }

package/dist/types/api/admin/product/ProductOption.d.ts

@@ -1,10 +1,6 @@
-import { Product } from "./Product";
 import { PropertyGroupOption } from "../propertyGroup/PropertyGroupOption";
 export interface ProductOption {
     id?: string;
-    productId: string;
-    productVersionId?: string;
     optionId: string;
-    product?: Product;
     option?: PropertyGroupOption;
 }

package/dist/types/api/admin/product/ProductPrice.d.ts

@@ -1,19 +1,15 @@
 import { GenericRecord } from "#types/api/global/GenericRecord";
-import { Product } from "./Product";
 import { Rule } from "../rule/Rule";
 import { CalculatedPrice } from "#types/api/store/price/CalculatedPrice";
 export interface ProductPrice {
     id: string;
     versionId?: string;
-    productId: string;
-    productVersionId?: string;
-    ruleId: string;
-    price?: Array<CalculatedPrice>;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
     quantityStart: number;
     quantityEnd?: number;
-    customFields?: GenericRecord;
-    readonly createdAt?: string;
-    readonly updatedAt?: string;
-    product?: Product;
+    ruleId: string;
     rule?: Rule;
+    price?: Array<CalculatedPrice>;
+    customFields?: GenericRecord;
 }

package/dist/types/api/admin/product/ProductProperty.d.ts

@@ -1,10 +1,6 @@
-import { Product } from "./Product";
 import { PropertyGroupOption } from "../propertyGroup/PropertyGroupOption";
 export interface ProductProperty {
     id?: string;
-    productId: string;
-    productVersionId?: string;
     optionId: string;
-    product?: Product;
     option?: PropertyGroupOption;
 }

package/dist/types/api/admin/product/ProductReview.d.ts

@@ -0,0 +1,5 @@
+import { ProductReview as StoreApiProductReview } from "#types/api/store/product/ProductReview";
+export type ProductReview = StoreApiProductReview & {
+    externalUser?: string;
+    externalEmail?: string;
+};

package/dist/types/api/admin/product/ProductSorting.d.ts

@@ -1,12 +1,12 @@
 export interface ProductSorting {
     id: string;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
+    active?: boolean;
+    label: string;
     locked?: boolean;
     key: string;
     priority: number;
-    active?: boolean;
     fields: object;
-    label: string;
-    readonly createdAt?: string;
-    readonly updatedAt?: string;
-    translated?: object;
+    translated?: Record<string, any>;
 }

package/dist/types/api/admin/product/category/ProductCategory.d.ts

@@ -1,11 +1,7 @@
-import { Product } from "../Product";
 import { Category } from "../../category/Category";
 export interface ProductCategory {
     id?: string;
-    productId: string;
-    productVersionId?: string;
     categoryId: string;
     categoryVersionId?: string;
-    product?: Product;
     category?: Category;
 }

package/dist/types/api/admin/product/category/ProductCategoryTree.d.ts

@@ -1,11 +1,7 @@
-import { Product } from "../Product";
 import { Category } from "../../category/Category";
 export interface ProductCategoryTree {
     id?: string;
-    productId: string;
-    productVersionId?: string;
     categoryId: string;
     categoryVersionId?: string;
-    product?: Product;
     category?: Category;
 }

package/dist/types/api/admin/product/crossSelling/ProductCrossSelling.d.ts

@@ -1,12 +1,8 @@
 import { ProductCrossSelling as StoreApiProductCrossSelling } from "#types/api/store/product/crossSelling/ProductCrossSelling";
-import { Product } from "../Product";
 import { ProductStream } from "../stream/ProductStream";
 import { ProductCrossSellingAssignedProduct } from "./ProductCrossSellingAssignedProduct";
 export type ProductCrossSelling = StoreApiProductCrossSelling & {
-    productId?: string;
-    productVersionId?: string;
     productStreamId?: string;
-    product?: Product;
     productStream?: ProductStream;
     assignedProducts?: Array<ProductCrossSellingAssignedProduct>;
 };

package/dist/types/api/admin/product/crossSelling/ProductCrossSellingAssignedProduct.d.ts

@@ -1,13 +1,8 @@
-import { Product } from "../Product";
 import { ProductCrossSelling } from "./ProductCrossSelling";
 export interface ProductCrossSellingAssignedProduct {
     id: string;
-    crossSellingId: string;
-    productId: string;
-    productVersionId?: string;
-    position?: number;
-    readonly createdAt?: string;
+    readonly createdAt: string;
     readonly updatedAt?: string;
-    product?: Product;
+    position?: number;
     crossSelling?: ProductCrossSelling;
 }

package/dist/types/api/admin/product/index.d.ts

@@ -1,21 +1,13 @@
 export * from "./category";
 export * from "./crossSelling";
-export * from "./review";
 export * from "./search";
 export * from "./stream";
-export * from "./warehouse";
 export { Product } from "./Product";
-export { ProductConfiguratorSetting } from "./ProductConfiguratorSetting";
-export { ProductCustomFieldSet } from "./ProductCustomFieldSet";
 export { ProductDownload } from "./ProductDownload";
-export { ProductExport } from "./ProductExport";
-export { ProductFeatureSet } from "./ProductFeatureSet";
-export { ProductKeywordDictionary } from "./ProductKeywordDictionary";
 export { ProductManufacturer } from "./ProductManufacturer";
 export { ProductMedia } from "./ProductMedia";
 export { ProductOption } from "./ProductOption";
 export { ProductPrice } from "./ProductPrice";
 export { ProductProperty } from "./ProductProperty";
+export { ProductReview } from "./ProductReview";
 export { ProductSorting } from "./ProductSorting";
-export { ProductTag } from "./ProductTag";
-export { ProductVisibility } from "./ProductVisibility";

package/dist/types/api/admin/product/search/ProductSearchKeyword.d.ts

@@ -3,13 +3,13 @@ import { Language } from "../../locale/Language";
 export interface ProductSearchKeyword {
     id: string;
     versionId?: string;
-    languageId: string;
-    productId: string;
-    productVersionId?: string;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
     keyword: string;
     ranking: number;
-    readonly createdAt?: string;
-    readonly updatedAt?: string;
+    productId: string;
+    productVersionId?: string;
     product?: Product;
+    languageId: string;
     language?: Language;
 }

package/dist/types/api/admin/product/search/config/ProductSearchConfig.d.ts

@@ -2,12 +2,12 @@ import { Language } from "../../../locale/Language";
 import { ProductSearchConfigField } from "./ProductSearchConfigField";
 export interface ProductSearchConfig {
     id: string;
-    languageId: string;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
     andLogic?: boolean;
     minSearchLength?: number;
     excludedTerms?: Array<string>;
-    readonly createdAt?: string;
-    readonly updatedAt?: string;
-    language?: Language;
     configFields?: Array<ProductSearchConfigField>;
+    languageId: string;
+    language?: Language;
 }

package/dist/types/api/admin/product/search/config/ProductSearchConfigField.d.ts

@@ -2,14 +2,13 @@ import { ProductSearchConfig } from "./ProductSearchConfig";
 import { CustomField } from "../../../custom/field/CustomField";
 export interface ProductSearchConfigField {
     id: string;
-    searchConfigId: string;
-    customFieldId?: string;
+    readonly createdAt: string;
+    readonly updatedAt?: string;
     field: string;
+    searchConfigId: string;
+    searchConfig?: ProductSearchConfig;
     tokenize?: boolean;
     searchable?: boolean;
     ranking?: number;
-    readonly createdAt?: string;
-    readonly updatedAt?: string;
-    searchConfig?: ProductSearchConfig;
     customField?: CustomField;
 }

package/dist/types/api/admin/product/stream/ProductStream.d.ts

@@ -1,13 +1,9 @@
 import { ProductStream as StoreApiProductStream } from "#types/api/store/product/ProductStream";
 import { ProductStreamFilter } from "./ProductStreamFilter";
-import { ProductCrossSelling } from "../crossSelling/ProductCrossSelling";
-import { ProductExport } from "../ProductExport";
 import { Category } from "../../category/Category";
 export type ProductStream = StoreApiProductStream & {
     readonly apiFilter?: string;
     readonly invalid?: boolean;
     filters?: Array<ProductStreamFilter>;
-    productCrossSelling?: Array<ProductCrossSelling>;
-    productExports?: Array<ProductExport>;
     categories?: Category;
 };