@commercetools/sync-actions 7.3.1 → 8.0.0-alpha.1

package/dist/declarations/api-extensions/api-extensions-actions.d.ts

@@ -0,0 +1,9 @@
+import { Delta, Extension, SyncActionConfig } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare const actionsMapBase: <T extends Extension>(diff: Delta, oldObj: T, newObj: T, config: SyncActionConfig) => {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/api-extensions/api-extensions.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, ActionGroup, SyncActionConfig, Extension, ExtensionUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Extension, ExtensionUpdateAction>;
+export default _default;

package/dist/declarations/assets/assets-actions.d.ts

@@ -0,0 +1,2 @@
+import { Asset, Delta, UpdateAction } from '../utils/types';
+export default function actionsMapAssets<T extends Asset>(diff: Delta, oldObj: T, newObj: T): Array<UpdateAction>;

package/dist/declarations/attribute-groups/attribute-groups-actions.d.ts

@@ -0,0 +1,10 @@
+import { AttributeGroup, Delta, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare function actionsMapBase<T>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapAttributes<T extends AttributeGroup>(diff: Delta, oldObj: T, newObj: T): Array<UpdateAction>;

package/dist/declarations/attribute-groups/attribute-groups.d.ts

@@ -0,0 +1,3 @@
+import type { SyncAction, ActionGroup, SyncActionConfig, AttributeGroupUpdateAction, AttributeGroup } from '../utils/types';
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<AttributeGroup, AttributeGroupUpdateAction>;
+export default _default;

package/dist/declarations/business-units/business-units-actions.d.ts

@@ -0,0 +1,10 @@
+import { Delta, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare const actionsMapAssociates: <T>(diff: Delta, oldObj: T, newObj: T) => Array<UpdateAction>;
+export declare const actionsMapBase: <T>(diff: Delta, oldObj: T, newObj: T, config: SyncActionConfig) => {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/business-units/business-units.d.ts

@@ -0,0 +1,3 @@
+import type { SyncAction, ActionGroup, SyncActionConfig, BusinessUnit, BusinessUnitUpdateAction } from '../utils/types';
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<BusinessUnit, BusinessUnitUpdateAction>;
+export default _default;

package/dist/declarations/cart-discounts/cart-discounts-actions.d.ts

@@ -0,0 +1,9 @@
+import { CartDiscount, Delta, SyncActionConfig } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare function actionsMapBase(diff: Delta, oldObj: CartDiscount, newObj: CartDiscount, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/cart-discounts/cart-discounts.d.ts

@@ -0,0 +1,4 @@
+import { ActionGroup, CartDiscount, CartDiscountUpdateAction, SyncAction, SyncActionConfig } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<CartDiscount, CartDiscountUpdateAction>;
+export default _default;

package/dist/declarations/categories/categories.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, Category, CategoryUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Category, CategoryUpdateAction>;
+export default _default;

package/dist/declarations/categories/category-actions.d.ts

@@ -0,0 +1,18 @@
+import { Category, Delta, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare const metaActionsList: Array<UpdateAction>;
+export declare const referenceActionsList: Array<UpdateAction>;
+/**
+ * SYNC FUNCTIONS
+ */
+export declare function actionsMapBase(diff: Delta, oldObj: Category, newObj: Category, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapReferences(diff: Delta, oldObj: Category, newObj: Category): {
+    action: string;
+}[];
+export declare function actionsMapMeta(diff: Delta, oldObj: Category, newObj: Category): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/channels/channels-actions.d.ts

@@ -0,0 +1,6 @@
+import { Channel, Delta, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: Channel, newObj: Channel, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/channels/channels.d.ts

@@ -0,0 +1,4 @@
+import { ActionGroup, Channel, ChannelUpdateAction, SyncAction, SyncActionConfig } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Channel, ChannelUpdateAction>;
+export default _default;

package/dist/declarations/customer-group/customer-group-actions.d.ts

@@ -0,0 +1,6 @@
+import { CustomerGroup, Delta, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: CustomerGroup, newObj: CustomerGroup, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/customer-group/customer-group.d.ts

@@ -0,0 +1,4 @@
+import { ActionGroup, CustomerGroup, SyncActionConfig, SyncAction, CustomerGroupUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<CustomerGroup, CustomerGroupUpdateAction>;
+export default _default;

package/dist/declarations/customers/customer-actions.d.ts

@@ -0,0 +1,25 @@
+import { Customer, Delta, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare const setDefaultBaseActionsList: Array<UpdateAction>;
+export declare const referenceActionsList: Array<UpdateAction>;
+export declare const authenticationModeActionsList: Array<UpdateAction>;
+/**
+ * SYNC FUNCTIONS
+ */
+export declare function actionsMapBase<T extends Customer>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapSetDefaultBase<T extends Customer>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapReferences<T extends Customer>(diff: Delta, oldObj: T, newObj: T): {
+    action: string;
+}[];
+export declare function actionsMapAddresses<T extends Customer>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];
+export declare function actionsMapAddBillingAddresses<T extends Customer>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];
+export declare function actionsMapRemoveBillingAddresses<T extends Customer>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];
+export declare function actionsMapAddShippingAddresses<T extends Customer>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];
+export declare function actionsMapRemoveShippingAddresses<T extends Customer>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];
+export declare function actionsMapAuthenticationModes<T extends Customer>(diff: Delta, oldObj: T, newObj: T): any;

package/dist/declarations/customers/customers.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, Customer, CustomerUpdateAction } from '../utils/types';
+export declare const actionGroups: Array<string>;
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Customer, CustomerUpdateAction>;
+export default _default;

package/dist/declarations/discount-codes/discount-codes-actions.d.ts

@@ -0,0 +1,6 @@
+import { Delta, DiscountCode, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: DiscountCode, newObj: DiscountCode, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/discount-codes/discount-codes.d.ts

@@ -0,0 +1,6 @@
+import { ActionGroup, DiscountCode, SyncActionConfig } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => {
+    buildActions: (now: DiscountCode, before: DiscountCode, options?: SyncActionConfig) => any[];
+};
+export default _default;

package/dist/declarations/index.d.ts

@@ -0,0 +1,26 @@
+export { default as createSyncCategories } from './categories/categories';
+export { default as createSyncCustomers } from './customers/customers';
+export { default as createSyncInventories } from './inventories/inventories';
+export { default as createSyncProducts } from './products/products';
+export { default as createSyncOrders } from './orders/orders';
+export { default as createSyncRecurringOrders } from './recurring-orders/recurring-orders';
+export { default as createSyncProductDiscounts } from './product-discounts/product-discounts';
+export { default as createSyncDiscountCodes } from './discount-codes/discount-codes';
+export { default as createSyncCustomerGroup } from './customer-group/customer-group';
+export { default as createSyncCartDiscounts } from './cart-discounts/cart-discounts';
+export { default as createSyncTaxCategories } from './tax-categories/tax-categories';
+export { default as createSyncZones } from './zones/zones';
+export { default as createSyncShippingMethods } from './shipping-methods/shipping-methods';
+export { default as createSyncProductTypes } from './product-types/product-types';
+export { default as createSyncStates } from './states/states';
+export { default as createSyncChannels } from './channels/channels';
+export { default as createSyncTypes } from './types/types';
+export { default as createSyncProjects } from './projects/projects';
+export { default as createSyncStores } from './stores/stores';
+export { default as createSyncProductSelections } from './product-selections/product-selections';
+export { default as createSyncStandalonePrices } from './prices/prices';
+export { default as createSyncAttributeGroups } from './attribute-groups/attribute-groups';
+export { default as createSyncApiExtensions } from './api-extensions/api-extensions';
+export { default as createSyncBusinessUnits } from './business-units/business-units';
+export { default as createSyncSubscriptions } from './subscriptions/subscriptions';
+export * from './utils/types';

package/dist/declarations/inventories/inventories.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, InventoryEntry, InventoryEntryUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<InventoryEntry, InventoryEntryUpdateAction>;
+export default _default;

package/dist/declarations/inventories/inventory-actions.d.ts

@@ -0,0 +1,13 @@
+import { Delta, InventoryEntry, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare const referenceActionsList: Array<UpdateAction>;
+/**
+ * SYNC FUNCTIONS
+ */
+export declare function actionsMapBase(diff: Delta, oldObj: InventoryEntry, newObj: InventoryEntry, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapReferences(diff: Delta, oldObj: InventoryEntry, newObj: InventoryEntry): {
+    action: string;
+}[];

package/dist/declarations/orders/order-actions.d.ts

@@ -0,0 +1,16 @@
+import { Delta, Order, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+/**
+ * SYNC FUNCTIONS
+ */
+export declare function actionsMapBase(diff: Delta, oldObj: Order, newObj: Order, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapDeliveries<T extends Order>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];
+export declare function actionsMapParcels<T extends Order>(diff: Delta, oldObj: T, newObj: T, deliveryHashMap: object): any[];
+export declare function actionsMapDeliveryItems<T extends Order>(diff: Delta, oldObj: T, newObj: T, deliveryHashMap: object): any[];
+export declare function actionsMapReturnsInfo<T extends Order>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];

package/dist/declarations/orders/orders.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, Order, OrderUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Order, OrderUpdateAction>;
+export default _default;

package/dist/declarations/prices/prices-actions.d.ts

@@ -0,0 +1,6 @@
+import { Delta, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase<T>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/prices/prices.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, StandalonePrice, StandalonePriceUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<StandalonePrice, StandalonePriceUpdateAction>;
+export default _default;

package/dist/declarations/product-discounts/product-discounts-actions.d.ts

@@ -0,0 +1,9 @@
+import { Delta, SyncActionConfig } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare function actionsMapBase<T>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/product-discounts/product-discounts.d.ts

@@ -0,0 +1,4 @@
+import { ActionGroup, ProductDiscount, ProductDiscountUpdateAction, SyncAction, SyncActionConfig } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<ProductDiscount, ProductDiscountUpdateAction>;
+export default _default;

package/dist/declarations/product-selections/product-selections-actions.d.ts

@@ -0,0 +1,9 @@
+import { Delta, ProductSelection, SyncActionConfig } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare function actionsMapBase(diff: Delta, oldObj: ProductSelection, newObj: ProductSelection, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/product-selections/product-selections.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, ActionGroup, ProductSelection, ProductSelectionUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList: Array<ActionGroup>) => SyncAction<ProductSelection, ProductSelectionUpdateAction>;
+export default _default;

package/dist/declarations/product-types/product-types-actions.d.ts

@@ -0,0 +1,11 @@
+import { Delta, ProductType, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare function actionsMapBase<T extends ProductType>(diff: Delta, previous: T, next: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare const generateBaseFieldsUpdateActions: <T extends object>(previous: T, next: T, actionDefinition: object) => Array<UpdateAction>;
+export declare const actionsMapForHints: <T extends ProductType>(nestedValuesChanges: Delta, ptOld: T, ptNew: T) => Array<UpdateAction>;

package/dist/declarations/product-types/product-types.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, ActionGroup, SyncActionConfig, ProductType, ProductTypeUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<ProductType, ProductTypeUpdateAction>;
+export default _default;

package/dist/declarations/products/product-actions.d.ts

@@ -0,0 +1,38 @@
+import { Category, Delta, ProductData, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare const baseAssetActionsList: Array<UpdateAction>;
+export declare const metaActionsList: Array<UpdateAction>;
+export declare const referenceActionsList: Array<UpdateAction>;
+/**
+ * SYNC FUNCTIONS
+ */
+export declare function actionsMapBase(diff: Delta, oldObj: object, newObj: object, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapMeta<T extends object>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapAddVariants<T extends object>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];
+export declare function actionsMapRemoveVariants<T extends object>(diff: Delta, oldObj: T, newObj: T): UpdateAction[];
+export declare function actionsMapReferences<T extends object>(diff: Delta, oldObj: T, newObj: T): {
+    action: string;
+}[];
+export declare function actionsMapCategories(diff: Delta): any[];
+export declare function actionsMapCategoryOrderHints(diff: Delta, _oldObj: Category): {
+    action: "setCategoryOrderHint";
+    categoryId: string;
+    orderHint?: string;
+    staged?: boolean;
+}[];
+export declare function actionsMapAssets<T extends object = ProductData>(diff: Delta, oldObj: T, newObj: T, variantHashMap: object): Array<UpdateAction>;
+export declare function actionsMapProductAttributes(diffedProductData: any, oldProductData: any, newProductData: any): any[];
+export declare function actionsMapAttributes(diff: any, oldObj: any, newObj: any, sameForAllAttributeNames: any[], variantHashMap: any): any;
+export declare function actionsMapImages(diff: any, oldObj: any, newObj: any, variantHashMap: any): any[];
+export declare function actionsMapPrices(diff: any, oldObj: any, newObj: any, variantHashMap: any, enableDiscounted: any): any[];
+export declare function actionsMapPricesCustom(diff: any, oldObj: any, newObj: any, variantHashMap: any): any[];
+export declare function actionsMapMasterVariant(oldObj: any, newObj: any): {
+    action: string;
+    variantId: any;
+}[];

package/dist/declarations/products/products.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, ProductData, ProductUpdateAction, Product } from '../utils/types';
+export declare const actionGroups: Array<string>;
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Product | ProductData, ProductUpdateAction>;
+export default _default;

package/dist/declarations/projects/projects-actions.d.ts

@@ -0,0 +1,17 @@
+import { Delta, Project, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare const myBusinessUnitActionsList: Array<UpdateAction>;
+export declare const customerSearchActionsList: Array<UpdateAction>;
+export declare const businessUnitSearchActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: Project, newObj: Project, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare const actionsMapBusinessUnit: (diff: Delta, oldObj: Project, newObj: Project, config?: SyncActionConfig) => {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapSearchIndexingConfiguration(diff: Delta, oldObj: Project, newObj: Project, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/projects/projects.d.ts

@@ -0,0 +1,4 @@
+import { ActionGroup, Project, ProjectUpdateAction, SyncAction, SyncActionConfig } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Project, ProjectUpdateAction>;
+export default _default;

package/dist/declarations/quotes/quotes-actions.d.ts

@@ -0,0 +1,6 @@
+import { Delta, Quote, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: Quote, newObj: Quote, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/quotes/quotes.d.ts

@@ -0,0 +1,5 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, Quote, QuoteUpdateAction } from '../utils/types';
+declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Quote, QuoteUpdateAction>;
+export default _default;
+export { actionGroups };

package/dist/declarations/quotes-requests/quote-requests-actions.d.ts

@@ -0,0 +1,6 @@
+import { Delta, Quote, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: Quote, newObj: Quote, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/quotes-requests/quote-requests.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, Quote, QuoteUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Quote, QuoteUpdateAction>;
+export default _default;

package/dist/declarations/recurring-orders/recurring-orders-actions.d.ts

@@ -0,0 +1,16 @@
+import { Delta, Order, SyncActionConfig } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare const referenceActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare function actionsMapBase(diff: Delta, oldObj: Order, newObj: Order, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapReferences(diff: Delta, oldObj: Order, newObj: Order): {
+    action: string;
+}[];

package/dist/declarations/recurring-orders/recurring-orders.d.ts

@@ -0,0 +1,5 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, OrderUpdateAction } from '../utils/types';
+import { Order } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Order, OrderUpdateAction>;
+export default _default;

package/dist/declarations/shipping-methods/shipping-methods-actions.d.ts

@@ -0,0 +1,10 @@
+import { Delta, ShippingMethod, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare function actionsMapBase<T>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapZoneRates(diff: Delta, oldObj: ShippingMethod, newObj: ShippingMethod): UpdateAction[];

package/dist/declarations/shipping-methods/shipping-methods.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, ShippingMethod, ShippingMethodUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<ShippingMethod, ShippingMethodUpdateAction>;
+export default _default;

package/dist/declarations/staged-quotes/staged-quotes-actions.d.ts

@@ -0,0 +1,6 @@
+import { Delta, Quote, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: Quote, newObj: Quote, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/staged-quotes/staged-quotes.d.ts

@@ -0,0 +1,5 @@
+import type { SyncAction, SyncActionConfig, ActionGroup, Quote, QuoteUpdateAction } from '../utils/types';
+declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Quote, QuoteUpdateAction>;
+export default _default;
+export { actionGroups };

package/dist/declarations/states/state-actions.d.ts

@@ -0,0 +1,7 @@
+import { Delta, State, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: State, newObj: State, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapRoles(diff: Delta, oldObj: State, newObj: State): UpdateAction[];

package/dist/declarations/states/states.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, ActionGroup, SyncActionConfig, State, StateUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<State, StateUpdateAction>;
+export default _default;

package/dist/declarations/stores/stores-actions.d.ts

@@ -0,0 +1,6 @@
+import { Delta, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase<T extends object>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/stores/stores.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, ActionGroup, SyncActionConfig, StoreUpdateAction, Store } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, options?: SyncActionConfig) => SyncAction<Store, StoreUpdateAction>;
+export default _default;

package/dist/declarations/subscriptions/subscriptions-actions.d.ts

@@ -0,0 +1,6 @@
+import { Delta, Subscription, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare const actionsMapBase: (diff: Delta, oldObj: Subscription, newObj: Subscription, config: SyncActionConfig) => {
+    [x: string]: any;
+    action: string;
+}[];

package/dist/declarations/subscriptions/subscriptions.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, ActionGroup, SyncActionConfig, Subscription, SubscriptionUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Subscription, SubscriptionUpdateAction>;
+export default _default;

package/dist/declarations/tax-categories/tax-categories-actions.d.ts

@@ -0,0 +1,7 @@
+import { Delta, SyncActionConfig, TaxCategory, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase(diff: Delta, oldObj: TaxCategory, newObj: TaxCategory, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapRates(diff: Delta, oldObj: Partial<TaxCategory>, newObj: Partial<TaxCategory>): UpdateAction[];

package/dist/declarations/tax-categories/tax-categories.d.ts

@@ -0,0 +1,4 @@
+import type { SyncAction, ActionGroup, SyncActionConfig, TaxCategory, TaxCategoryUpdateAction } from '../utils/types';
+export declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<TaxCategory, TaxCategoryUpdateAction>;
+export default _default;

package/dist/declarations/types/types-actions.d.ts

@@ -0,0 +1,7 @@
+import { CustomFieldEnumType, Delta, FieldDefinition, SyncActionConfig, UpdateAction } from '../utils/types';
+export declare const baseActionsList: Array<UpdateAction>;
+export declare function actionsMapBase<T = CustomFieldEnumType | FieldDefinition>(diff: Delta, oldObj: T, newObj: T, config?: SyncActionConfig): {
+    [x: string]: any;
+    action: string;
+}[];
+export declare function actionsMapFieldDefinitions(fieldDefinitionsDiff: Delta, previous: FieldDefinition, next: FieldDefinition | Array<FieldDefinition>, diffPaths: Delta): any;

package/dist/declarations/types/types.d.ts

@@ -0,0 +1,5 @@
+import { ActionGroup, SyncAction, SyncActionConfig, Type, TypeUpdateAction } from '../utils/types';
+declare const actionGroups: string[];
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Type, TypeUpdateAction>;
+export default _default;
+export { actionGroups };

package/dist/declarations/utils/action-map-custom.d.ts

@@ -0,0 +1,5 @@
+import { Delta } from './types';
+export default function actionsMapCustom(diff: Delta, newObj: any, oldObj: any, customProps?: {
+    actions: object;
+    [key: string]: unknown;
+}): any[];

package/dist/declarations/utils/clone.d.ts

@@ -0,0 +1,6 @@
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export default function clone<T>(obj: T): Mutable<T>;
+export declare function notEmpty<T>(value: T | null | undefined): value is T;
+export {};

package/dist/declarations/utils/combine-validity-actions.d.ts

@@ -0,0 +1 @@
+export default function combineValidityActions(actions?: any[]): any[];

package/dist/declarations/utils/common-actions.d.ts

@@ -0,0 +1,46 @@
+import { Delta, UpdateAction } from './types';
+export declare const createIsEmptyValue: <T extends string | object>(emptyValues: T[]) => (value: string | unknown) => boolean;
+export declare const isOptionalField: (action: string) => boolean;
+/**
+ * Builds actions for simple object properties, given a list of actions
+ * E.g. [{ action: `changeName`, key: 'name' }]
+ *
+ * @param  {Array} options.actions - a list of actions to be built
+ * based on the given property
+ * @param  {Object} options.diff - the diff object
+ * @param  {Object} options.oldObj - the object that needs to be updated
+ * @param  {Object} options.newObj - the new representation of the object
+ * @param {Boolean} options.shouldOmitEmptyString - a flag to determine if we should treat an empty string a NON-value
+ * @param {Boolean} options.shouldUnsetOmittedProperties - a flag to determine if we should unset fields which are omitted in the newObj
+ * @param {Boolean} options.shouldPreventUnsettingRequiredFields - a flag to determine if required fields should be unset
+ */
+export declare function buildBaseAttributesActions<T, U>({ actions, diff, oldObj, newObj, shouldOmitEmptyString, shouldUnsetOmittedProperties, shouldPreventUnsettingRequiredFields, }: {
+    actions: Array<UpdateAction>;
+    diff: Delta;
+    oldObj: T;
+    newObj: U;
+    shouldOmitEmptyString?: boolean;
+    shouldUnsetOmittedProperties?: boolean;
+    shouldPreventUnsettingRequiredFields?: boolean;
+}): {
+    [x: string]: any;
+    action: string;
+}[];
+/**
+ * Builds actions for simple reference objects, given a list of actions
+ * E.g. [{ action: `setTaxCategory`, key: 'taxCategory' }]
+ *
+ * @param  {Array} options.actions - a list of actions to be built
+ * based on the given property
+ * @param  {Object} options.diff - the diff object
+ * @param  {Object} options.oldObj - the object that needs to be updated
+ * @param  {Object} options.newObj - the new representation of the object
+ */
+export declare function buildReferenceActions<T>({ actions, diff, oldObj, newObj, }: {
+    actions: Array<UpdateAction>;
+    diff: Delta;
+    oldObj: T;
+    newObj: T;
+}): {
+    action: string;
+}[];