@commercetools/sync-actions 7.1.2 → 7.2.0-alpha.0

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,25 @@
+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';

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, ProductUpdateAction, Product } from '../utils/types';
+export declare const actionGroups: Array<string>;
+declare const _default: (actionGroupList?: Array<ActionGroup>, syncActionConfig?: SyncActionConfig) => SyncAction<Product, 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,9 @@
+import { Delta, Order, SyncActionConfig } from '../utils/types';
+export declare const baseActionsList: {
+    action: string;
+    key: string;
+}[];
+export declare function actionsMapBase(diff: Delta, oldObj: Order, newObj: Order, config?: SyncActionConfig): {
+    [x: string]: any;
+    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 object | string>(emptyValues: Array<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;
+}[];

package/dist/declarations/utils/copy-empty-array-props.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @function copyEmptyArrayProps
+ * @description Create new key with empty array value on `newobj` for the arrays exist on `oldObj` and doesnt exist on `newobj`
+ * One use case is to easily compare two object without generating this error `Cannot read property '0' of undefined`
+ * @param {Object} oldObj
+ * @param {Object} newObj
+ * @returns {Array} Ordered Array [oldObj, newObj]
+ */
+export default function copyEmptyArrayProps(oldObj?: {}, newObj?: {}): {}[];

package/dist/declarations/utils/create-build-actions.d.ts

@@ -0,0 +1,4 @@
+import { Delta, SyncActionConfig, UpdateAction } from './types';
+type Preprocessor<T> = (before: T, now: T) => Array<T>;
+export default function createBuildActions<S extends object, T extends UpdateAction>(differ: (processedBefore: S, processedNow: S) => Delta, doMapActions: (diffed: Delta, processedNow: S, processedBefore: S, options: SyncActionConfig) => Array<T>, onBeforeDiff?: Preprocessor<S>, buildActionsConfig?: SyncActionConfig): (now: S, before: S, options?: SyncActionConfig) => T[];
+export {};

package/dist/declarations/utils/create-build-array-actions.d.ts

@@ -0,0 +1,15 @@
+import { Delta, UpdateAction } from './types';
+export declare const ADD_ACTIONS = "create";
+export declare const REMOVE_ACTIONS = "remove";
+export declare const CHANGE_ACTIONS = "change";
+/**
+ * Generate + configure a function to build actions for nested objects
+ * @param  {string} key    key of the attribute containing the array of
+ *   nested objects
+ * @param  {object} config configuration object that can contain the keys
+ *   [ADD_ACTIONS, REMOVE_ACTIONS, CHANGE_ACTIONS], each of
+ *   which is a function. The function should accept the old + new arrays and
+ *   return an action object.
+ * @return {Array}        The generated array of actions
+ */
+export default function createBuildArrayActions(key: string, config: object): <S, T extends UpdateAction>(diff: Delta, oldObj: S, newObj: S) => T[];

package/dist/declarations/utils/create-map-action-group.d.ts

@@ -0,0 +1,2 @@
+import { ActionGroup, UpdateAction } from './types';
+export default function createMapActionGroup(actionGroups?: Array<ActionGroup>): (type: string, fn: () => Array<UpdateAction>) => UpdateAction[];

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

@@ -0,0 +1,11 @@
+import { Delta } from './types';
+type U = {
+    id: string;
+    name: string;
+    url: string;
+};
+export declare function objectHash<O extends U, I extends string | number>(obj: O, index: I): string;
+export declare function diff<T>(oldObj: T, newObj: T): Delta;
+export declare function patch<T>(obj: T, delta: Delta): any;
+export declare function getDeltaValue<T extends object = object>(arr: Array<number> | unknown, originalObject?: T): T;
+export {};

package/dist/declarations/utils/extract-matching-pairs.d.ts

@@ -0,0 +1,4 @@
+export default function extractMatchingPairs<T extends object>(hashMap: object, key: string, before: T, now: T): {
+    oldObj: T;
+    newObj: T;
+};

package/dist/declarations/utils/find-matching-pairs.d.ts

@@ -0,0 +1,2 @@
+import { Delta } from './types';
+export default function findMatchingPairs<T extends object>(diff: Delta, before?: Array<T>, now?: Array<T>, identifier?: string): T;

package/dist/declarations/utils/remove-typename.d.ts

@@ -0,0 +1,3 @@
+export default function removeTypename(obj: object & {
+    __typename?: string;
+}): {};

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

@@ -0,0 +1,31 @@
+import type { Delta as DiffDelta } from 'jsondiffpatch/dist/jsondiffpatch.cjs';
+export type * from '@commercetools/platform-sdk';
+export type Delta = DiffDelta | undefined;
+export type SyncActionConfig = {
+    shouldOmitEmptyString?: boolean;
+    shouldUnsetOmittedProperties?: boolean;
+    shouldPreventUnsettingRequiredFields?: boolean;
+    sameForAllAttributeNames?: unknown[];
+    enableDiscounted?: boolean;
+    withHints?: boolean;
+    [key: string]: unknown;
+};
+export type SyncAction<R extends object | undefined, S extends UpdateAction | unknown, T extends object = SyncActionConfig> = {
+    buildActions: (now: DeepPartial<R>, before: DeepPartial<R>, config?: T) => Array<S>;
+};
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type UpdateAction = {
+    action: string | never;
+    key?: string;
+    actionKey?: string;
+    roles?: Array<unknown>;
+    value?: string;
+};
+export type ActionGroup = {
+    type: string;
+    group: 'ignore' | 'allow' | string;
+};
+export type MapActionGroup = (type: string, cb: () => Array<UpdateAction>) => Array<UpdateAction>;
+export type MapAction<T> = (mapActionGroup: MapActionGroup, syncActionConfig?: SyncActionConfig) => (diff: Delta, newObj: T, oldObj: T, config?: SyncActionConfig) => Array<UpdateAction>;

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

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

package/dist/declarations/zones/zones.d.ts

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