@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import express from 'express';
 import { SetupServer } from 'msw/node';
 import * as ctp from '@commercetools/platform-sdk';
-import { Project, ResourceIdentifier, QueryParam, AssociateRoleDraft, AssociateRole, AssociateRoleSetNameAction, AssociateRoleSetPermissionsAction, AssociateRoleChangeBuyerAssignableAction, AssociateRoleSetCustomFieldAction, AssociateRoleAddPermissionAction, AssociateRoleRemovePermissionAction, AttributeGroupDraft, AttributeGroup, AttributeGroupSetAttributesAction, AttributeGroupChangeNameAction, AttributeGroupSetDescriptionAction, AttributeGroupSetKeyAction, BusinessUnitDraft, BusinessUnit, BusinessUnitAddAddressAction, BusinessUnitAddAssociateAction, BusinessUnitSetAssociatesAction, BusinessUnitSetContactEmailAction, BusinessUnitSetStoreModeAction, BusinessUnitChangeNameAction, BusinessUnitChangeAddressAction, BusinessUnitAddStoreAction, BusinessUnitChangeParentUnitAction, BusinessUnitChangeStatusAction, CartDraft, Cart, CartAddLineItemAction, CartAddItemShippingAddressAction, CartChangeLineItemQuantityAction, CartRemoveLineItemAction, CartSetBillingAddressAction, CartSetShippingMethodAction, CartSetCountryAction, CartSetCustomerEmailAction, CartSetCustomFieldAction, CartSetCustomShippingMethodAction, CartSetCustomTypeAction, CartSetDirectDiscountsAction, CartSetLocaleAction, CartSetLineItemShippingDetailsAction, CartSetShippingAddressAction, CartRemoveDiscountCodeAction, LineItemDraft, LineItem, CartDiscountDraft, CartDiscount, CartDiscountUpdateAction, AssetDraft, Asset, CategoryDraft, Category, CategoryChangeAssetNameAction, CategoryChangeSlugAction, CategoryChangeNameAction, CategoryChangeParentAction, CategorySetKeyAction, CategorySetAssetDescriptionAction, CategorySetAssetSourcesAction, CategorySetDescriptionAction, CategorySetMetaDescriptionAction, CategorySetMetaKeywordsAction, CategorySetMetaTitleAction, CategorySetCustomTypeAction, CategorySetCustomFieldAction, CategoryRemoveAssetAction, CategoryAddAssetAction, ChannelDraft, Channel, ChannelUpdateAction, CustomObjectDraft, CustomObject, CustomerDraft, Customer, CustomerChangeEmailAction, CustomerSetFirstNameAction, CustomerSetLastNameAction, CustomerSetCompanyNameAction, CustomerSetVatIdAction, CustomerChangeAddressAction, CustomerSetAuthenticationModeAction, CustomerSetCustomFieldAction, CustomerSetCustomerNumberAction, CustomerGroupDraft, CustomerGroup, CustomerGroupSetKeyAction, CustomerGroupChangeNameAction, CustomerGroupSetCustomTypeAction, CustomerGroupSetCustomFieldAction, DiscountCodeDraft, DiscountCode, DiscountCodeUpdateAction, Extension, ExtensionDraft, ExtensionUpdateAction, InventoryEntryDraft, InventoryEntry, InventoryEntryChangeQuantityAction, InventoryEntrySetExpectedDeliveryAction, InventoryEntrySetCustomFieldAction, InventoryEntrySetCustomTypeAction, InventoryEntrySetRestockableInDaysAction, OrderFromCartDraft, Order, CartReference, OrderImportDraft, OrderAddPaymentAction, OrderAddReturnInfoAction, OrderChangeOrderStateAction, OrderChangePaymentStateAction, OrderTransitionStateAction, OrderSetBillingAddressAction, OrderSetCustomerEmailAction, OrderSetCustomFieldAction, OrderSetCustomTypeAction, OrderSetLocaleAction, OrderSetOrderNumberAction, OrderSetShippingAddressAction, OrderSetStoreAction, OrderUpdateSyncInfoAction, MyOrderFromCartDraft, OrderEditDraft, OrderEdit, OrderEditUpdateAction, PaymentDraft, Payment, TransactionDraft, Transaction, PaymentUpdateAction, ProductDraft, Product, ProductUpdateAction, ProductDiscountDraft, ProductDiscount, ProductDiscountUpdateAction, ProductProjectionPagedSearchResponse, ProductProjection, FacetResults, TermFacetResult, FilteredFacetResult, RangeFacetResult, ProductSelectionDraft, ProductSelection, ProductSelectionUpdateAction, ProductTypeDraft, ProductType, AttributeDefinitionDraft, AttributeDefinition, ProductTypeUpdateAction, ProjectUpdateAction, QuoteDraft, Quote, QuoteUpdateAction, QuoteRequestDraft, QuoteRequest, QuoteRequestUpdateAction, ReviewDraft, Review, ReviewUpdateAction, ShippingMethodDraft, ShippingMethod, ZoneReference, ShippingRate, ShippingMethodUpdateAction, ShoppingListDraft, ShoppingList, ShoppingListSetKeyAction, ShoppingListSetSlugAction, ShoppingListChangeNameAction, ShoppingListSetDescriptionAction, ShoppingListSetCustomerAction, ShoppingListSetStoreAction, ShoppingListSetAnonymousIdAction, ShoppingListSetCustomTypeAction, ShoppingListSetCustomFieldAction, ShoppingListSetDeleteDaysAfterLastModificationAction, ShoppingListAddLineItemAction, ShoppingListRemoveLineItemAction, ShoppingListChangeLineItemQuantityAction, ShoppingListLineItem, StagedQuoteDraft, StagedQuote, StagedQuoteUpdateAction, StandalonePriceDraft, StandalonePrice, ChannelResourceIdentifier, ChannelReference, DiscountedPriceDraft, StandalonePriceChangeActiveAction, StandalonePriceChangeValueAction, StandalonePriceSetDiscountedPriceAction, StateDraft, State, StateUpdateAction, StoreDraft, Store, StoreUpdateAction, SubscriptionDraft, Subscription, TaxCategoryDraft, TaxCategory, TaxCategoryUpdateAction, TypeDraft, Type, TypeUpdateAction, ZoneDraft, Zone, ZoneUpdateAction, BaseResource, UpdateAction } from '@commercetools/platform-sdk';
+import { QueryParam, BaseResource, Project, UpdateAction, ResourceIdentifier, AssociateRoleDraft, AssociateRole, AttributeGroupDraft, AttributeGroup, BusinessUnitDraft, BusinessUnit, CartDraft, Cart, LineItemDraft, LineItem, CartDiscountDraft, CartDiscount, CategoryDraft, Category, ChannelDraft, Channel, CustomObjectDraft, CustomObject, CustomerDraft, Customer, CustomerToken, CustomerGroupDraft, CustomerGroup, DiscountCodeDraft, DiscountCode, ExtensionDraft, Extension, InventoryEntryDraft, InventoryEntry, MyCustomerChangePassword, MyCustomerResetPassword, OrderFromCartDraft, Order, CartReference, OrderImportDraft, MyOrderFromCartDraft, OrderEditDraft, OrderEdit, PaymentDraft, Payment, ProductDraft, Product, ProductDiscountDraft, ProductDiscount, ProductProjectionPagedSearchResponse, ProductProjection, FacetResults, TermFacetResult, FilteredFacetResult, RangeFacetResult, ProductSelectionDraft, ProductSelection, ProductTypeDraft, ProductType, QuoteDraft, Quote, QuoteRequestDraft, QuoteRequest, ReviewDraft, Review, ShippingMethodDraft, ShippingMethod, ZoneReference, ShoppingListDraft, ShoppingList, ShoppingListLineItem, StagedQuoteDraft, StagedQuote, StandalonePriceDraft, StandalonePrice, ChannelResourceIdentifier, ChannelReference, StateDraft, State, StoreDraft, Store, SubscriptionDraft, Subscription, TaxCategoryDraft, TaxCategory, TypeDraft, Type, ZoneDraft, Zone } from '@commercetools/platform-sdk';
 
 type Token = {
     access_token: string;
-    token_type: 'Bearer';
+    token_type: "Bearer";
     expires_in: number;
     scope: string;
     refresh_token?: string;
@@ -27,10 +27,138 @@ declare class OAuth2Store {
     validateToken(token: string): boolean;
 }
 
+type QueryParams$1 = {
+    expand?: string[];
+    where?: string[];
+    offset?: number;
+    limit?: number;
+    [key: string]: QueryParam;
+};
 type GetParams$1 = {
     expand?: string[];
 };
-type QueryParams$1 = {
+type RepositoryContext = {
+    projectKey: string;
+    storeKey?: string;
+};
+declare abstract class AbstractRepository<R extends BaseResource | Project> {
+    protected _storage: AbstractStorage;
+    protected actions: AbstractUpdateHandler | undefined;
+    constructor(storage: AbstractStorage);
+    abstract saveNew({ projectKey }: RepositoryContext, resource: R): void;
+    abstract saveUpdate({ projectKey }: RepositoryContext, version: number, resource: R): void;
+    abstract postProcessResource(resource: any): any;
+    processUpdateActions(context: RepositoryContext, resource: R, version: number, actions: UpdateAction[]): R;
+}
+declare abstract class AbstractResourceRepository<T extends ResourceType> extends AbstractRepository<ResourceMap[T]> {
+    protected _typeId: T;
+    constructor(typeId: T, storage: AbstractStorage);
+    abstract create(context: RepositoryContext, draft: any): ResourceMap[T];
+    protected getTypeId(): T;
+    delete(context: RepositoryContext, id: string, params?: GetParams$1): ResourceMap[T] | null;
+    get(context: RepositoryContext, id: string, params?: GetParams$1): ResourceMap[T] | null;
+    getByKey(context: RepositoryContext, key: string, params?: GetParams$1): ResourceMap[T] | null;
+    postProcessResource(resource: ResourceMap[T]): ResourceMap[T];
+    query(context: RepositoryContext, params?: QueryParams$1): PagedQueryResponseMap[T];
+    saveNew(context: RepositoryContext, resource: ShallowWritable<ResourceMap[T]>): ResourceMap[T];
+    saveUpdate(context: RepositoryContext, version: number, resource: ShallowWritable<ResourceMap[T]>): ShallowWritable<ResourceMap[T]>;
+}
+declare class AbstractUpdateHandler {
+    protected _storage: AbstractStorage;
+    constructor(_storage: AbstractStorage);
+    apply<R extends BaseResource | Project>(context: RepositoryContext, resource: R, version: number, actions: UpdateAction[]): R;
+}
+
+type Writable<T> = {
+    -readonly [P in keyof T]: Writable<T[P]>;
+};
+type ShallowWritable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+type ResourceType = keyof ResourceMap & keyof RepositoryMap;
+type ResourceMap = {
+    "attribute-group": ctp.AttributeGroup;
+    "associate-role": ctp.AssociateRole;
+    "business-unit": ctp.BusinessUnit;
+    "cart-discount": ctp.CartDiscount;
+    "cart": ctp.Cart;
+    "category": ctp.Category;
+    "channel": ctp.Channel;
+    "customer-email-token": never;
+    "customer-group": ctp.CustomerGroup;
+    "customer-password-token": never;
+    "customer": ctp.Customer;
+    "discount-code": ctp.DiscountCode;
+    "extension": ctp.Extension;
+    "inventory-entry": ctp.InventoryEntry;
+    "key-value-document": ctp.CustomObject;
+    "order-edit": ctp.OrderEdit;
+    "order": ctp.Order;
+    "payment": ctp.Payment;
+    "product-discount": ctp.ProductDiscount;
+    "product-price": ctp.StandalonePrice;
+    "product-projection": ctp.ProductProjection;
+    "product-selection": ctp.ProductSelection;
+    "product-type": ctp.ProductType;
+    "product": ctp.Product;
+    "quote-request": ctp.QuoteRequest;
+    "quote": ctp.Quote;
+    "review": ctp.Review;
+    "shipping-method": ctp.ShippingMethod;
+    "shopping-list": ctp.ShoppingList;
+    "staged-quote": ctp.StagedQuote;
+    "standalone-price": ctp.StandalonePrice;
+    "state": ctp.State;
+    "store": ctp.Store;
+    "subscription": ctp.Subscription;
+    "tax-category": ctp.TaxCategory;
+    "type": ctp.Type;
+    "zone": ctp.Zone;
+};
+type PagedQueryResponseMap = {
+    "attribute-group": ctp.AttributeGroupPagedQueryResponse;
+    "associate-role": ctp.AssociateRolePagedQueryResponse;
+    "business-unit": ctp.BusinessUnitPagedQueryResponse;
+    "cart-discount": ctp.CartDiscountPagedQueryResponse;
+    "cart": ctp.CartPagedQueryResponse;
+    "category": ctp.CategoryPagedQueryResponse;
+    "channel": ctp.ChannelPagedQueryResponse;
+    "customer-email-token": never;
+    "customer-group": ctp.CustomerGroupPagedQueryResponse;
+    "customer-password-token": never;
+    "customer": ctp.CustomerPagedQueryResponse;
+    "discount-code": ctp.DiscountCodePagedQueryResponse;
+    "extension": ctp.ExtensionPagedQueryResponse;
+    "inventory-entry": ctp.InventoryPagedQueryResponse;
+    "key-value-document": ctp.CustomObjectPagedQueryResponse;
+    "order-edit": ctp.OrderEditPagedQueryResponse;
+    "order": ctp.OrderPagedQueryResponse;
+    "payment": ctp.PaymentPagedQueryResponse;
+    "product-discount": ctp.ProductDiscountPagedQueryResponse;
+    "product-price": ctp.StandalonePricePagedQueryResponse;
+    "product-projection": ctp.ProductProjectionPagedQueryResponse;
+    "product-selection": ctp.ProductSelectionPagedQueryResponse;
+    "product-type": ctp.ProductTypePagedQueryResponse;
+    "product": ctp.ProductPagedQueryResponse;
+    "quote-request": ctp.QuoteRequestPagedQueryResponse;
+    "quote": ctp.QuotePagedQueryResponse;
+    "review": ctp.ReviewPagedQueryResponse;
+    "shipping-method": ctp.ShippingMethodPagedQueryResponse;
+    "shopping-list": ctp.ShoppingListPagedQueryResponse;
+    "staged-quote": ctp.StagedQuotePagedQueryResponse;
+    "standalone-price": ctp.StandalonePricePagedQueryResponse;
+    "state": ctp.StatePagedQueryResponse;
+    "store": ctp.StorePagedQueryResponse;
+    "subscription": ctp.SubscriptionPagedQueryResponse;
+    "tax-category": ctp.TaxCategoryPagedQueryResponse;
+    "type": ctp.TypePagedQueryResponse;
+    "zone": ctp.ZonePagedQueryResponse;
+};
+
+type GetParams = {
+    expand?: string[];
+};
+type QueryParams = {
     expand?: string | string[];
     sort?: string | string[];
     limit?: number;
@@ -42,242 +170,131 @@ type QueryParams$1 = {
 declare abstract class AbstractStorage {
     abstract clear(): void;
     abstract all<RT extends ResourceType>(projectKey: string, typeId: RT): Array<ResourceMap[RT]>;
-    abstract add<RT extends ResourceType>(projectKey: string, typeId: RT, obj: ResourceMap[RT]): void;
-    abstract get<RT extends ResourceType>(projectKey: string, typeId: RT, id: string, params?: GetParams$1): ResourceMap[RT] | null;
-    abstract getByKey<RT extends ResourceType>(projectKey: string, typeId: RT, key: string, params: GetParams$1): ResourceMap[RT] | null;
+    abstract add<RT extends ResourceType>(projectKey: string, typeId: RT, obj: ResourceMap[RT]): ResourceMap[RT];
+    abstract get<RT extends ResourceType>(projectKey: string, typeId: RT, id: string, params?: GetParams): ResourceMap[RT] | null;
+    abstract getByKey<RT extends ResourceType>(projectKey: string, typeId: RT, key: string, params: GetParams): ResourceMap[RT] | null;
     abstract addProject(projectKey: string): Project;
     abstract getProject(projectKey: string): Project;
     abstract saveProject(project: Project): Project;
-    abstract delete<RT extends ResourceType>(projectKey: string, typeId: RT, id: string, params: GetParams$1): ResourceMap[RT] | null;
-    abstract query<RT extends ResourceType>(projectKey: string, typeId: RT, params: QueryParams$1): PagedQueryResponseMap[RT];
+    abstract delete<RT extends ResourceType>(projectKey: string, typeId: RT, id: string, params: GetParams): ResourceMap[RT] | null;
+    abstract query<RT extends ResourceType>(projectKey: string, typeId: RT, params: QueryParams): PagedQueryResponseMap[RT];
     abstract getByResourceIdentifier<RT extends ResourceType>(projectKey: string, identifier: ResourceIdentifier): ResourceMap[RT];
     abstract expand<T>(projectKey: string, obj: T, clause: undefined | string | string[]): T;
 }
 
-declare class AssociateRoleRepository extends AbstractResourceRepository<'associate-role'> {
-    getTypeId(): "associate-role";
+declare class AssociateRoleRepository extends AbstractResourceRepository<"associate-role"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: AssociateRoleDraft): AssociateRole;
-    actions: {
-        setName: (context: RepositoryContext, resource: Writable<AssociateRole>, { name }: AssociateRoleSetNameAction) => void;
-        setPermissions: (context: RepositoryContext, resource: Writable<AssociateRole>, { permissions }: AssociateRoleSetPermissionsAction) => void;
-        setBuyerAssignable: (context: RepositoryContext, resource: Writable<AssociateRole>, { buyerAssignable }: AssociateRoleChangeBuyerAssignableAction) => void;
-        changeBuyerAssignable: (context: RepositoryContext, resource: Writable<AssociateRole>, { buyerAssignable }: AssociateRoleChangeBuyerAssignableAction) => void;
-        setCustomFields: (context: RepositoryContext, resource: Writable<AssociateRole>, { name, value }: AssociateRoleSetCustomFieldAction) => void;
-        addPermission: (context: RepositoryContext, resource: Writable<AssociateRole>, { permission }: AssociateRoleAddPermissionAction) => void;
-        removePermission: (context: RepositoryContext, resource: Writable<AssociateRole>, { permission }: AssociateRoleRemovePermissionAction) => void;
-    };
 }
 
-declare class AttributeGroupRepository extends AbstractResourceRepository<'attribute-group'> {
-    getTypeId(): "attribute-group";
+declare class AttributeGroupRepository extends AbstractResourceRepository<"attribute-group"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: AttributeGroupDraft): AttributeGroup;
-    actions: {
-        setAttributes: (_context: RepositoryContext, resource: Writable<AttributeGroup>, { attributes }: AttributeGroupSetAttributesAction) => void;
-        changeName: (_context: RepositoryContext, resource: Writable<AttributeGroup>, { name }: AttributeGroupChangeNameAction) => void;
-        setDescription: (_context: RepositoryContext, resource: Writable<AttributeGroup>, { description }: AttributeGroupSetDescriptionAction) => void;
-        setKey: (_context: RepositoryContext, resource: Writable<AttributeGroup>, { key }: AttributeGroupSetKeyAction) => void;
-    };
 }
 
-declare class BusinessUnitRepository extends AbstractResourceRepository<'business-unit'> {
-    getTypeId(): "business-unit";
+declare class BusinessUnitRepository extends AbstractResourceRepository<"business-unit"> {
+    constructor(storage: AbstractStorage);
+    create(context: RepositoryContext, draft: BusinessUnitDraft): BusinessUnit;
     private _isCompanyDraft;
     private _isDivisionDraft;
-    create(context: RepositoryContext, draft: BusinessUnitDraft): BusinessUnit;
-    actions: {
-        addAddress: (context: RepositoryContext, resource: Writable<BusinessUnit>, { address }: BusinessUnitAddAddressAction) => void;
-        addAssociate: (context: RepositoryContext, resource: Writable<BusinessUnit>, { associate }: BusinessUnitAddAssociateAction) => void;
-        setAssociates: (context: RepositoryContext, resource: Writable<BusinessUnit>, { associates }: BusinessUnitSetAssociatesAction) => void;
-        setContactEmail: (context: RepositoryContext, resource: Writable<BusinessUnit>, { contactEmail }: BusinessUnitSetContactEmailAction) => void;
-        setStoreMode: (context: RepositoryContext, resource: Writable<BusinessUnit>, { storeMode }: BusinessUnitSetStoreModeAction) => void;
-        changeAssociateMode: (context: RepositoryContext, resource: Writable<BusinessUnit>, { storeMode }: BusinessUnitSetStoreModeAction) => void;
-        changeName: (context: RepositoryContext, resource: Writable<BusinessUnit>, { name }: BusinessUnitChangeNameAction) => void;
-        changeAddress: (context: RepositoryContext, resource: Writable<BusinessUnit>, { address }: BusinessUnitChangeAddressAction) => void;
-        addStore: (context: RepositoryContext, resource: Writable<BusinessUnit>, { store }: BusinessUnitAddStoreAction) => void;
-        changeParentUnit: (context: RepositoryContext, resource: Writable<BusinessUnit>, { parentUnit }: BusinessUnitChangeParentUnitAction) => void;
-        changeStatus: (context: RepositoryContext, resource: Writable<BusinessUnit>, { status }: BusinessUnitChangeStatusAction) => void;
-    };
 }
 
-declare class CartRepository extends AbstractResourceRepository<'cart'> {
-    getTypeId(): "cart";
+declare class CartRepository extends AbstractResourceRepository<"cart"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: CartDraft): Cart;
     getActiveCart(projectKey: string): Cart | undefined;
-    actions: {
-        addLineItem: (context: RepositoryContext, resource: Writable<Cart>, { productId, variantId, sku, quantity }: CartAddLineItemAction) => void;
-        recalculate: () => void;
-        addItemShippingAddress: (context: RepositoryContext, resource: Writable<Cart>, { action, address }: CartAddItemShippingAddressAction) => void;
-        changeLineItemQuantity: (context: RepositoryContext, resource: Writable<Cart>, { lineItemId, lineItemKey, quantity }: CartChangeLineItemQuantityAction) => void;
-        removeLineItem: (context: RepositoryContext, resource: Writable<Cart>, { lineItemId, quantity }: CartRemoveLineItemAction) => void;
-        setBillingAddress: (context: RepositoryContext, resource: Writable<Cart>, { address }: CartSetBillingAddressAction) => void;
-        setShippingMethod: (context: RepositoryContext, resource: Writable<Cart>, { shippingMethod }: CartSetShippingMethodAction) => void;
-        setCountry: (context: RepositoryContext, resource: Writable<Cart>, { country }: CartSetCountryAction) => void;
-        setCustomerEmail: (context: RepositoryContext, resource: Writable<Cart>, { email }: CartSetCustomerEmailAction) => void;
-        setCustomField: (context: RepositoryContext, resource: Cart, { name, value }: CartSetCustomFieldAction) => void;
-        setCustomShippingMethod: (context: RepositoryContext, resource: Writable<Cart>, { shippingMethodName, shippingRate, taxCategory, externalTaxRate, }: CartSetCustomShippingMethodAction) => void;
-        setCustomType: (context: RepositoryContext, resource: Writable<Cart>, { type, fields }: CartSetCustomTypeAction) => void;
-        setDirectDiscounts: (context: RepositoryContext, resource: Writable<Cart>, { discounts }: CartSetDirectDiscountsAction) => void;
-        setLocale: (context: RepositoryContext, resource: Writable<Cart>, { locale }: CartSetLocaleAction) => void;
-        setLineItemShippingDetails: (context: RepositoryContext, resource: Writable<Cart>, { action, shippingDetails, lineItemId, lineItemKey, }: CartSetLineItemShippingDetailsAction) => void;
-        setShippingAddress: (context: RepositoryContext, resource: Writable<Cart>, { address }: CartSetShippingAddressAction) => void;
-        removeDiscountCode: (context: RepositoryContext, resource: Writable<Cart>, { discountCode }: CartRemoveDiscountCodeAction) => void;
-    };
     draftLineItemtoLineItem: (projectKey: string, draftLineItem: LineItemDraft, currency: string, country: string | undefined) => LineItem;
 }
 
-declare class CartDiscountRepository extends AbstractResourceRepository<'cart-discount'> {
-    getTypeId(): "cart-discount";
+declare class CartDiscountRepository extends AbstractResourceRepository<"cart-discount"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: CartDiscountDraft): CartDiscount;
     private transformValueDraft;
-    actions: Partial<Record<CartDiscountUpdateAction['action'], (context: RepositoryContext, resource: Writable<CartDiscount>, action: any) => void>>;
 }
 
-declare class CategoryRepository extends AbstractResourceRepository<'category'> {
-    getTypeId(): "category";
-    assetFromAssetDraft: (draft: AssetDraft, context: RepositoryContext) => Asset;
+declare class CategoryRepository extends AbstractResourceRepository<"category"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: CategoryDraft): Category;
-    actions: {
-        changeAssetName: (context: RepositoryContext, resource: Writable<Category>, { assetId, assetKey, name }: CategoryChangeAssetNameAction) => void;
-        changeSlug: (context: RepositoryContext, resource: Writable<Category>, { slug }: CategoryChangeSlugAction) => void;
-        changeName: (context: RepositoryContext, resource: Writable<Category>, { name }: CategoryChangeNameAction) => void;
-        changeParent: (context: RepositoryContext, resource: Writable<Category>, { parent }: CategoryChangeParentAction) => void;
-        setKey: (context: RepositoryContext, resource: Writable<Category>, { key }: CategorySetKeyAction) => void;
-        setAssetDescription: (context: RepositoryContext, resource: Writable<Category>, { assetId, assetKey, description }: CategorySetAssetDescriptionAction) => void;
-        setAssetSources: (context: RepositoryContext, resource: Writable<Category>, { assetId, assetKey, sources }: CategorySetAssetSourcesAction) => void;
-        setDescription: (context: RepositoryContext, resource: Writable<Category>, { description }: CategorySetDescriptionAction) => void;
-        setMetaDescription: (context: RepositoryContext, resource: Writable<Category>, { metaDescription }: CategorySetMetaDescriptionAction) => void;
-        setMetaKeywords: (context: RepositoryContext, resource: Writable<Category>, { metaKeywords }: CategorySetMetaKeywordsAction) => void;
-        setMetaTitle: (context: RepositoryContext, resource: Writable<Category>, { metaTitle }: CategorySetMetaTitleAction) => void;
-        setCustomType: (context: RepositoryContext, resource: Writable<Category>, { type, fields }: CategorySetCustomTypeAction) => void;
-        setCustomField: (context: RepositoryContext, resource: Writable<Category>, { name, value }: CategorySetCustomFieldAction) => void;
-        removeAsset: (context: RepositoryContext, resource: Writable<Category>, { assetId, assetKey }: CategoryRemoveAssetAction) => void;
-        addAsset: (context: RepositoryContext, resource: Writable<Category>, { asset }: CategoryAddAssetAction) => void;
-    };
 }
 
-declare class ChannelRepository extends AbstractResourceRepository<'channel'> {
-    getTypeId(): "channel";
+declare class ChannelRepository extends AbstractResourceRepository<"channel"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ChannelDraft): Channel;
-    actions: Partial<Record<ChannelUpdateAction['action'], (context: RepositoryContext, resource: Writable<Channel>, action: any) => void>>;
 }
 
-declare class CustomObjectRepository extends AbstractResourceRepository<'key-value-document'> {
-    getTypeId(): "key-value-document";
+declare class CustomObjectRepository extends AbstractResourceRepository<"key-value-document"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: Writable<CustomObjectDraft>): CustomObject;
-    queryWithContainer(context: RepositoryContext, container: string, params?: QueryParams): ctp.CustomObjectPagedQueryResponse;
     getWithContainerAndKey(context: RepositoryContext, container: string, key: string): CustomObject | undefined;
+    queryWithContainer(context: RepositoryContext, container: string, params?: QueryParams$1): ctp.CustomObjectPagedQueryResponse;
 }
 
-declare class CustomerRepository extends AbstractResourceRepository<'customer'> {
-    getTypeId(): "customer";
+declare class CustomerRepository extends AbstractResourceRepository<"customer"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: CustomerDraft): Customer;
-    getMe(context: RepositoryContext): Customer | undefined;
-    deleteMe(context: RepositoryContext): Customer | undefined;
-    actions: {
-        changeEmail: (_context: RepositoryContext, resource: Writable<Customer>, { email }: CustomerChangeEmailAction) => void;
-        setFirstName: (_context: RepositoryContext, resource: Writable<Customer>, { firstName }: CustomerSetFirstNameAction) => void;
-        setLastName: (_context: RepositoryContext, resource: Writable<Customer>, { lastName }: CustomerSetLastNameAction) => void;
-        setCompanyName: (_context: RepositoryContext, resource: Writable<Customer>, { companyName }: CustomerSetCompanyNameAction) => void;
-        setVatId: (_context: RepositoryContext, resource: Writable<Customer>, { vatId }: CustomerSetVatIdAction) => void;
-        changeAddress: (context: RepositoryContext, resource: Writable<Customer>, { addressId, addressKey, address }: CustomerChangeAddressAction) => void;
-        setAuthenticationMode: (_context: RepositoryContext, resource: Writable<Customer>, { authMode, password }: CustomerSetAuthenticationModeAction) => void;
-        setCustomField: (_context: RepositoryContext, resource: Writable<Customer>, { name, value }: CustomerSetCustomFieldAction) => void;
-        setCustomerNumber: (_context: RepositoryContext, resource: Writable<Customer>, { customerNumber }: CustomerSetCustomerNumberAction) => void;
-    };
+    passwordResetToken(context: RepositoryContext, email: string): CustomerToken;
 }
 
-declare class CustomerGroupRepository extends AbstractResourceRepository<'customer-group'> {
-    getTypeId(): "customer-group";
+declare class CustomerGroupRepository extends AbstractResourceRepository<"customer-group"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: CustomerGroupDraft): CustomerGroup;
-    actions: {
-        setKey: (context: RepositoryContext, resource: Writable<CustomerGroup>, { key }: CustomerGroupSetKeyAction) => void;
-        changeName: (context: RepositoryContext, resource: Writable<CustomerGroup>, { name }: CustomerGroupChangeNameAction) => void;
-        setCustomType: (context: RepositoryContext, resource: Writable<CustomerGroup>, { type, fields }: CustomerGroupSetCustomTypeAction) => void;
-        setCustomField: (context: RepositoryContext, resource: Writable<CustomerGroup>, { name, value }: CustomerGroupSetCustomFieldAction) => void;
-    };
 }
 
-declare class DiscountCodeRepository extends AbstractResourceRepository<'discount-code'> {
-    getTypeId(): "discount-code";
+declare class DiscountCodeRepository extends AbstractResourceRepository<"discount-code"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: DiscountCodeDraft): DiscountCode;
-    actions: Partial<Record<DiscountCodeUpdateAction['action'], (context: RepositoryContext, resource: Writable<DiscountCode>, action: any) => void>>;
 }
 
-declare class ExtensionRepository extends AbstractResourceRepository<'extension'> {
-    getTypeId(): "extension";
-    postProcessResource(resource: Extension): Extension;
+declare class ExtensionRepository extends AbstractResourceRepository<"extension"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ExtensionDraft): Extension;
-    actions: Record<ExtensionUpdateAction['action'], (context: RepositoryContext, resource: Writable<Extension>, action: any) => void>;
+    postProcessResource(resource: Extension): Extension;
 }
 
-declare class InventoryEntryRepository extends AbstractResourceRepository<'inventory-entry'> {
-    getTypeId(): "inventory-entry";
+declare class InventoryEntryRepository extends AbstractResourceRepository<"inventory-entry"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: InventoryEntryDraft): InventoryEntry;
-    actions: {
-        changeQuantity: (context: RepositoryContext, resource: Writable<InventoryEntry>, { quantity }: InventoryEntryChangeQuantityAction) => void;
-        setExpectedDelivery: (context: RepositoryContext, resource: Writable<InventoryEntry>, { expectedDelivery }: InventoryEntrySetExpectedDeliveryAction) => void;
-        setCustomField: (context: RepositoryContext, resource: InventoryEntry, { name, value }: InventoryEntrySetCustomFieldAction) => void;
-        setCustomType: (context: RepositoryContext, resource: Writable<InventoryEntry>, { type, fields }: InventoryEntrySetCustomTypeAction) => void;
-        setRestockableInDays: (context: RepositoryContext, resource: Writable<InventoryEntry>, { restockableInDays }: InventoryEntrySetRestockableInDaysAction) => void;
-    };
 }
 
-declare class OrderRepository extends AbstractResourceRepository<'order'> {
-    getTypeId(): "order";
+declare class MyCustomerRepository extends CustomerRepository {
+    changePassword(context: RepositoryContext, changePassword: MyCustomerChangePassword): Writable<Customer>;
+    deleteMe(context: RepositoryContext): Customer | undefined;
+    getMe(context: RepositoryContext): Customer | undefined;
+    resetPassword(context: RepositoryContext, resetPassword: MyCustomerResetPassword): Writable<Customer>;
+}
+
+declare class OrderRepository extends AbstractResourceRepository<"order"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: OrderFromCartDraft): Order;
     createFromCart(context: RepositoryContext, cartReference: CartReference, orderNumber?: string): Order;
     import(context: RepositoryContext, draft: OrderImportDraft): Order;
     private lineItemFromImportDraft;
     private customLineItemFromImportDraft;
-    getWithOrderNumber(context: RepositoryContext, orderNumber: string, params?: QueryParams): Order | undefined;
-    actions: {
-        addPayment: (context: RepositoryContext, resource: Writable<Order>, { payment }: OrderAddPaymentAction) => void;
-        addReturnInfo: (context: RepositoryContext, resource: Writable<Order>, info: OrderAddReturnInfoAction) => void;
-        changeOrderState: (context: RepositoryContext, resource: Writable<Order>, { orderState }: OrderChangeOrderStateAction) => void;
-        changePaymentState: (context: RepositoryContext, resource: Writable<Order>, { paymentState }: OrderChangePaymentStateAction) => void;
-        transitionState: (context: RepositoryContext, resource: Writable<Order>, { state }: OrderTransitionStateAction) => void;
-        setBillingAddress: (context: RepositoryContext, resource: Writable<Order>, { address }: OrderSetBillingAddressAction) => void;
-        setCustomerEmail: (context: RepositoryContext, resource: Writable<Order>, { email }: OrderSetCustomerEmailAction) => void;
-        setCustomField: (context: RepositoryContext, resource: Order, { name, value }: OrderSetCustomFieldAction) => void;
-        setCustomType: (context: RepositoryContext, resource: Writable<Order>, { type, fields }: OrderSetCustomTypeAction) => void;
-        setLocale: (context: RepositoryContext, resource: Writable<Order>, { locale }: OrderSetLocaleAction) => void;
-        setOrderNumber: (context: RepositoryContext, resource: Writable<Order>, { orderNumber }: OrderSetOrderNumberAction) => void;
-        setShippingAddress: (context: RepositoryContext, resource: Writable<Order>, { address }: OrderSetShippingAddressAction) => void;
-        setStore: (context: RepositoryContext, resource: Writable<Order>, { store }: OrderSetStoreAction) => void;
-        updateSyncInfo: (context: RepositoryContext, resource: Writable<Order>, { channel, externalId, syncedAt }: OrderUpdateSyncInfoAction) => void;
-    };
+    getWithOrderNumber(context: RepositoryContext, orderNumber: string, params?: QueryParams$1): Order | undefined;
 }
 
 declare class MyOrderRepository extends OrderRepository {
     create(context: RepositoryContext, draft: MyOrderFromCartDraft): Order;
 }
 
-declare class OrderEditRepository extends AbstractResourceRepository<'order-edit'> {
-    getTypeId(): "order-edit";
+declare class OrderEditRepository extends AbstractResourceRepository<"order-edit"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: OrderEditDraft): OrderEdit;
-    actions: Partial<Record<OrderEditUpdateAction['action'], (context: RepositoryContext, resource: Writable<OrderEdit>, action: any) => void>>;
 }
 
-declare class PaymentRepository extends AbstractResourceRepository<'payment'> {
-    getTypeId(): "payment";
+declare class PaymentRepository extends AbstractResourceRepository<"payment"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: PaymentDraft): Payment;
-    transactionFromTransactionDraft: (draft: TransactionDraft, context: RepositoryContext) => Transaction;
-    actions: Record<PaymentUpdateAction['action'], (context: RepositoryContext, resource: Writable<Payment>, action: any) => void>;
 }
 
-declare class ProductRepository extends AbstractResourceRepository<'product'> {
-    getTypeId(): "product";
+declare class ProductRepository extends AbstractResourceRepository<"product"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ProductDraft): Product;
-    private variantFromDraft;
-    private priceFromDraft;
-    actions: Partial<Record<ProductUpdateAction['action'], (context: RepositoryContext, resource: Writable<Product>, action: any) => void>>;
 }
 
-declare class ProductDiscountRepository extends AbstractResourceRepository<'product-discount'> {
-    getTypeId(): "product-discount";
+declare class ProductDiscountRepository extends AbstractResourceRepository<"product-discount"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ProductDiscountDraft): ProductDiscount;
-    private transformValueDraft;
-    actions: Partial<Record<ProductDiscountUpdateAction['action'], (context: RepositoryContext, resource: Writable<ProductDiscount>, action: any) => void>>;
 }
 
 /**
@@ -285,36 +302,36 @@ declare class ProductDiscountRepository extends AbstractResourceRepository<'prod
  */
 
 type RangeExpression = {
-    type: 'RangeExpression';
+    type: "RangeExpression";
     start?: number;
     stop?: number;
     match: (obj: any) => boolean;
 };
 type FilterExpression = {
-    type: 'FilterExpression';
+    type: "FilterExpression";
     match: (obj: any) => boolean;
 };
 
 type ProductProjectionSearchParams = {
-    fuzzy?: boolean;
-    fuzzyLevel?: number;
-    markMatchingVariants?: boolean;
-    staged?: boolean;
-    filter?: string[];
-    'filter.facets'?: string[];
-    'filter.query'?: string[];
-    facet?: string | string[];
-    sort?: string | string[];
-    limit?: number;
-    offset?: number;
-    withTotal?: boolean;
-    priceCurrency?: string;
-    priceCountry?: string;
-    priceCustomerGroup?: string;
-    priceChannel?: string;
-    localeProjection?: string;
-    storeProjection?: string;
-    expand?: string | string[];
+    "fuzzy"?: boolean;
+    "fuzzyLevel"?: number;
+    "markMatchingVariants"?: boolean;
+    "staged"?: boolean;
+    "filter"?: string[];
+    "filter.facets"?: string[];
+    "filter.query"?: string[];
+    "facet"?: string | string[];
+    "sort"?: string | string[];
+    "limit"?: number;
+    "offset"?: number;
+    "withTotal"?: boolean;
+    "priceCurrency"?: string;
+    "priceCountry"?: string;
+    "priceCustomerGroup"?: string;
+    "priceChannel"?: string;
+    "localeProjection"?: string;
+    "storeProjection"?: string;
+    "expand"?: string | string[];
     [key: string]: QueryParam;
 };
 declare class ProductProjectionSearch {
@@ -349,12 +366,11 @@ type ProductProjectionQueryParams = {
     where?: string | string[];
     [key: string]: QueryParam;
 };
-declare class ProductProjectionRepository extends AbstractResourceRepository<'product-projection'> {
+declare class ProductProjectionRepository extends AbstractResourceRepository<"product-projection"> {
     protected _searchService: ProductProjectionSearch;
     constructor(storage: AbstractStorage);
-    getTypeId(): "product-projection";
     create(context: RepositoryContext, draft: ProductDraft): ProductProjection;
-    get(context: RepositoryContext, id: string, params?: GetParams): ProductProjection | null;
+    get(context: RepositoryContext, id: string, params?: GetParams$1): ProductProjection | null;
     query(context: RepositoryContext, params?: ProductProjectionQueryParams): {
         count: number;
         total: number;
@@ -363,58 +379,49 @@ declare class ProductProjectionRepository extends AbstractResourceRepository<'pr
         results: ProductProjection[];
     };
     search(context: RepositoryContext, query: ProductProjectionQueryParams): ctp.ProductProjectionPagedSearchResponse;
-    actions: {};
 }
 
-declare class ProductSelectionRepository extends AbstractResourceRepository<'product-selection'> {
-    getTypeId(): "product-selection";
+declare class ProductSelectionRepository extends AbstractResourceRepository<"product-selection"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ProductSelectionDraft): ProductSelection;
-    actions: Partial<Record<ProductSelectionUpdateAction['action'], (context: RepositoryContext, resource: Writable<ProductSelection>, action: any) => void>>;
 }
 
-declare class ProductTypeRepository extends AbstractResourceRepository<'product-type'> {
-    getTypeId(): "product-type";
+declare class ProductTypeRepository extends AbstractResourceRepository<"product-type"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ProductTypeDraft): ProductType;
-    attributeDefinitionFromAttributeDefinitionDraft: (_context: RepositoryContext, draft: AttributeDefinitionDraft) => AttributeDefinition;
-    actions: Partial<Record<ProductTypeUpdateAction['action'], (context: RepositoryContext, resource: Writable<ProductType>, action: any) => void>>;
 }
 
 declare class ProjectRepository extends AbstractRepository<Project> {
+    constructor(storage: AbstractStorage);
     get(context: RepositoryContext): Project | null;
     postProcessResource(resource: Project): Project;
     saveNew(context: RepositoryContext, resource: Writable<Project>): void;
     saveUpdate(context: RepositoryContext, version: number, resource: Project): void;
-    actions: Partial<Record<ProjectUpdateAction['action'], (context: RepositoryContext, resource: Writable<Project>, action: any) => void>>;
 }
 
-declare class QuoteRepository extends AbstractResourceRepository<'quote'> {
-    getTypeId(): "quote";
+declare class QuoteRepository extends AbstractResourceRepository<"quote"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: QuoteDraft): Quote;
-    actions: Partial<Record<QuoteUpdateAction['action'], (context: RepositoryContext, resource: Writable<Quote>, action: any) => void>>;
 }
 
-declare class QuoteRequestRepository extends AbstractResourceRepository<'quote-request'> {
-    getTypeId(): "quote-request";
+declare class QuoteRequestRepository extends AbstractResourceRepository<"quote-request"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: QuoteRequestDraft): QuoteRequest;
-    actions: Partial<Record<QuoteRequestUpdateAction['action'], (context: RepositoryContext, resource: Writable<QuoteRequest>, action: any) => void>>;
 }
 
-declare class ReviewRepository extends AbstractResourceRepository<'review'> {
-    getTypeId(): "review";
+declare class ReviewRepository extends AbstractResourceRepository<"review"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ReviewDraft): Review;
-    actions: Partial<Record<ReviewUpdateAction['action'], (context: RepositoryContext, resource: Writable<Review>, action: any) => void>>;
 }
 
-declare class ShippingMethodRepository extends AbstractResourceRepository<'shipping-method'> {
-    getTypeId(): "shipping-method";
+declare class ShippingMethodRepository extends AbstractResourceRepository<"shipping-method"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ShippingMethodDraft): ShippingMethod;
-    private _transformZoneRateDraft;
-    private _transformShippingRate;
-    matchingCart(context: RepositoryContext, cartId: string, params?: GetParams): {
+    matchingCart(context: RepositoryContext, cartId: string, params?: GetParams$1): {
         results: {
             zoneRates: {
                 zone: ZoneReference;
-                shippingRates: ShippingRate[];
+                shippingRates: ctp.ShippingRate[];
             }[];
             id: string;
             version: number;
@@ -437,261 +444,107 @@ declare class ShippingMethodRepository extends AbstractResourceRepository<'shipp
         total?: number | undefined;
         offset?: number | undefined;
     } | undefined;
-    actions: Partial<Record<ShippingMethodUpdateAction['action'], (context: RepositoryContext, resource: Writable<ShippingMethod>, action: any) => void>>;
+    private _transformZoneRateDraft;
 }
 
-declare class ShoppingListRepository extends AbstractResourceRepository<'shopping-list'> {
-    getTypeId(): "shopping-list";
+declare class ShoppingListRepository extends AbstractResourceRepository<"shopping-list"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ShoppingListDraft): ShoppingList;
-    actions: {
-        setKey: (context: RepositoryContext, resource: Writable<ShoppingList>, { key }: ShoppingListSetKeyAction) => void;
-        setSlug: (context: RepositoryContext, resource: Writable<ShoppingList>, { slug }: ShoppingListSetSlugAction) => void;
-        changeName: (context: RepositoryContext, resource: Writable<ShoppingList>, { name }: ShoppingListChangeNameAction) => void;
-        setDescription: (context: RepositoryContext, resource: Writable<ShoppingList>, { description }: ShoppingListSetDescriptionAction) => void;
-        setCustomer: (context: RepositoryContext, resource: Writable<ShoppingList>, { customer }: ShoppingListSetCustomerAction) => void;
-        setStore: (context: RepositoryContext, resource: Writable<ShoppingList>, { store }: ShoppingListSetStoreAction) => void;
-        setAnonymousId: (context: RepositoryContext, resource: Writable<ShoppingList>, { anonymousId }: ShoppingListSetAnonymousIdAction) => void;
-        setCustomType: (context: RepositoryContext, resource: Writable<ShoppingList>, { type, fields }: ShoppingListSetCustomTypeAction) => void;
-        setCustomField: (context: RepositoryContext, resource: ShoppingList, { name, value }: ShoppingListSetCustomFieldAction) => void;
-        setDeleteDaysAfterLastModification: (context: RepositoryContext, resource: Writable<ShoppingList>, { deleteDaysAfterLastModification, }: ShoppingListSetDeleteDaysAfterLastModificationAction) => void;
-        addLineItem: (context: RepositoryContext, resource: Writable<ShoppingList>, { productId, variantId, sku, quantity }: ShoppingListAddLineItemAction) => void;
-        removeLineItem: (context: RepositoryContext, resource: Writable<ShoppingList>, { lineItemId, quantity }: ShoppingListRemoveLineItemAction) => void;
-        changeLineItemQuantity: (context: RepositoryContext, resource: Writable<ShoppingList>, { lineItemId, lineItemKey, quantity, }: ShoppingListChangeLineItemQuantityAction) => void;
-    };
     draftLineItemtoLineItem: (projectKey: string, draftLineItem: LineItemDraft) => ShoppingListLineItem;
 }
 
-declare class StagedQuoteRepository extends AbstractResourceRepository<'staged-quote'> {
-    getTypeId(): "staged-quote";
+declare class StagedQuoteRepository extends AbstractResourceRepository<"staged-quote"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: StagedQuoteDraft): StagedQuote;
-    actions: Partial<Record<StagedQuoteUpdateAction['action'], (context: RepositoryContext, resource: Writable<Quote>, action: any) => void>>;
 }
 
-declare class StandAlonePriceRepository extends AbstractResourceRepository<'standalone-price'> {
-    getTypeId(): "standalone-price";
+declare class StandAlonePriceRepository extends AbstractResourceRepository<"standalone-price"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: StandalonePriceDraft): StandalonePrice;
     transformChannelReferenceDraft(channel: ChannelResourceIdentifier): ChannelReference;
-    transformDiscountDraft(discounted: DiscountedPriceDraft): {
-        value: ctp.TypedMoney;
-        discount: ctp.ProductDiscountReference;
-    };
-    actions: {
-        setActive: (context: RepositoryContext, resource: Writable<StandalonePrice>, action: StandalonePriceChangeActiveAction) => void;
-        changeValue: (context: RepositoryContext, resource: Writable<StandalonePrice>, action: StandalonePriceChangeValueAction) => void;
-        setDiscountedPrice: (context: RepositoryContext, resource: Writable<StandalonePrice>, action: StandalonePriceSetDiscountedPriceAction) => void;
-    };
 }
 
-declare class StateRepository extends AbstractResourceRepository<'state'> {
-    getTypeId(): "state";
+declare class StateRepository extends AbstractResourceRepository<"state"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: StateDraft): State;
-    actions: Partial<Record<StateUpdateAction['action'], (context: RepositoryContext, resource: Writable<State>, action: any) => void>>;
 }
 
-declare class StoreRepository extends AbstractResourceRepository<'store'> {
-    getTypeId(): "store";
+declare class StoreRepository extends AbstractResourceRepository<"store"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: StoreDraft): Store;
-    private transformChannels;
-    actions: Partial<Record<StoreUpdateAction['action'], (context: RepositoryContext, resource: Writable<Store>, action: any) => void>>;
 }
 
-declare class SubscriptionRepository extends AbstractResourceRepository<'subscription'> {
-    getTypeId(): "subscription";
+declare class SubscriptionRepository extends AbstractResourceRepository<"subscription"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: SubscriptionDraft): Subscription;
 }
 
-declare class TaxCategoryRepository extends AbstractResourceRepository<'tax-category'> {
-    getTypeId(): "tax-category";
+declare class TaxCategoryRepository extends AbstractResourceRepository<"tax-category"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: TaxCategoryDraft): TaxCategory;
-    private taxRateFromTaxRateDraft;
-    actions: Partial<Record<TaxCategoryUpdateAction['action'], (context: RepositoryContext, resource: Writable<TaxCategory>, action: any) => void>>;
 }
 
-declare class TypeRepository extends AbstractResourceRepository<'type'> {
-    getTypeId(): "type";
+declare class TypeRepository extends AbstractResourceRepository<"type"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: TypeDraft): Type;
-    actions: Partial<Record<TypeUpdateAction['action'], (context: RepositoryContext, resource: Writable<Type>, action: any) => void>>;
 }
 
-declare class ZoneRepository extends AbstractResourceRepository<'zone'> {
-    getTypeId(): "zone";
+declare class ZoneRepository extends AbstractResourceRepository<"zone"> {
+    constructor(storage: AbstractStorage);
     create(context: RepositoryContext, draft: ZoneDraft): Zone;
-    actions: Partial<Record<ZoneUpdateAction['action'], (context: RepositoryContext, resource: Writable<Zone>, action: any) => void>>;
 }
 
 type RepositoryMap = ReturnType<typeof createRepositories>;
 declare const createRepositories: (storage: AbstractStorage) => {
-    'associate-role': AssociateRoleRepository;
-    'attribute-group': AttributeGroupRepository;
-    'business-unit': BusinessUnitRepository;
+    "associate-role": AssociateRoleRepository;
+    "attribute-group": AttributeGroupRepository;
+    "business-unit": BusinessUnitRepository;
     category: CategoryRepository;
     cart: CartRepository;
-    'cart-discount': CartDiscountRepository;
+    "cart-discount": CartDiscountRepository;
     customer: CustomerRepository;
     channel: ChannelRepository;
-    'customer-group': CustomerGroupRepository;
-    'discount-code': DiscountCodeRepository;
+    "customer-group": CustomerGroupRepository;
+    "discount-code": DiscountCodeRepository;
     extension: ExtensionRepository;
-    'inventory-entry': InventoryEntryRepository;
-    'key-value-document': CustomObjectRepository;
+    "inventory-entry": InventoryEntryRepository;
+    "key-value-document": CustomObjectRepository;
     order: OrderRepository;
-    'order-edit': OrderEditRepository;
+    "order-edit": OrderEditRepository;
     payment: PaymentRepository;
-    'my-cart': CartRepository;
-    'my-order': MyOrderRepository;
-    'my-customer': CustomerRepository;
-    'my-payment': PaymentRepository;
-    'my-shopping-list': ShoppingListRepository;
+    "my-cart": CartRepository;
+    "my-order": MyOrderRepository;
+    "my-customer": MyCustomerRepository;
+    "my-payment": PaymentRepository;
+    "my-shopping-list": ShoppingListRepository;
     product: ProductRepository;
-    'product-type': ProductTypeRepository;
-    'product-discount': ProductDiscountRepository;
-    'product-projection': ProductProjectionRepository;
-    'product-selection': ProductSelectionRepository;
+    "product-type": ProductTypeRepository;
+    "product-discount": ProductDiscountRepository;
+    "product-projection": ProductProjectionRepository;
+    "product-selection": ProductSelectionRepository;
     project: ProjectRepository;
     review: ReviewRepository;
     quote: QuoteRepository;
-    'quote-request': QuoteRequestRepository;
-    'shipping-method': ShippingMethodRepository;
-    'shopping-list': ShoppingListRepository;
-    'staged-quote': StagedQuoteRepository;
-    'standalone-price': StandAlonePriceRepository;
+    "quote-request": QuoteRequestRepository;
+    "shipping-method": ShippingMethodRepository;
+    "shopping-list": ShoppingListRepository;
+    "staged-quote": StagedQuoteRepository;
+    "standalone-price": StandAlonePriceRepository;
     state: StateRepository;
     store: StoreRepository;
     subscription: SubscriptionRepository;
-    'tax-category': TaxCategoryRepository;
+    "tax-category": TaxCategoryRepository;
     type: TypeRepository;
     zone: ZoneRepository;
 };
 
-type Writable<T> = {
-    -readonly [P in keyof T]: Writable<T[P]>;
-};
-type ShallowWritable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-type ResourceType = keyof ResourceMap & keyof RepositoryMap;
-type ResourceMap = {
-    'attribute-group': ctp.AttributeGroup;
-    'associate-role': ctp.AssociateRole;
-    'business-unit': ctp.BusinessUnit;
-    'cart-discount': ctp.CartDiscount;
-    cart: ctp.Cart;
-    category: ctp.Category;
-    channel: ctp.Channel;
-    'customer-email-token': never;
-    'customer-group': ctp.CustomerGroup;
-    'customer-password-token': never;
-    customer: ctp.Customer;
-    'discount-code': ctp.DiscountCode;
-    extension: ctp.Extension;
-    'inventory-entry': ctp.InventoryEntry;
-    'key-value-document': ctp.CustomObject;
-    'order-edit': ctp.OrderEdit;
-    order: ctp.Order;
-    payment: ctp.Payment;
-    'product-discount': ctp.ProductDiscount;
-    'product-price': ctp.StandalonePrice;
-    'product-projection': ctp.ProductProjection;
-    'product-selection': ctp.ProductSelection;
-    'product-type': ctp.ProductType;
-    product: ctp.Product;
-    'quote-request': ctp.QuoteRequest;
-    quote: ctp.Quote;
-    review: ctp.Review;
-    'shipping-method': ctp.ShippingMethod;
-    'shopping-list': ctp.ShoppingList;
-    'staged-quote': ctp.StagedQuote;
-    'standalone-price': ctp.StandalonePrice;
-    state: ctp.State;
-    store: ctp.Store;
-    subscription: ctp.Subscription;
-    'tax-category': ctp.TaxCategory;
-    type: ctp.Type;
-    zone: ctp.Zone;
-};
-type PagedQueryResponseMap = {
-    'attribute-group': ctp.AttributeGroupPagedQueryResponse;
-    'associate-role': ctp.AssociateRolePagedQueryResponse;
-    'business-unit': ctp.BusinessUnitPagedQueryResponse;
-    'cart-discount': ctp.CartDiscountPagedQueryResponse;
-    cart: ctp.CartPagedQueryResponse;
-    category: ctp.CategoryPagedQueryResponse;
-    channel: ctp.ChannelPagedQueryResponse;
-    'customer-email-token': never;
-    'customer-group': ctp.CustomerGroupPagedQueryResponse;
-    'customer-password-token': never;
-    customer: ctp.CustomerPagedQueryResponse;
-    'discount-code': ctp.DiscountCodePagedQueryResponse;
-    extension: ctp.ExtensionPagedQueryResponse;
-    'inventory-entry': ctp.InventoryPagedQueryResponse;
-    'key-value-document': ctp.CustomObjectPagedQueryResponse;
-    'order-edit': ctp.OrderEditPagedQueryResponse;
-    order: ctp.OrderPagedQueryResponse;
-    payment: ctp.PaymentPagedQueryResponse;
-    'product-discount': ctp.ProductDiscountPagedQueryResponse;
-    'product-price': ctp.StandalonePricePagedQueryResponse;
-    'product-projection': ctp.ProductProjectionPagedQueryResponse;
-    'product-selection': ctp.ProductSelectionPagedQueryResponse;
-    'product-type': ctp.ProductTypePagedQueryResponse;
-    product: ctp.ProductPagedQueryResponse;
-    'quote-request': ctp.QuoteRequestPagedQueryResponse;
-    quote: ctp.QuotePagedQueryResponse;
-    review: ctp.ReviewPagedQueryResponse;
-    'shipping-method': ctp.ShippingMethodPagedQueryResponse;
-    'shopping-list': ctp.ShoppingListPagedQueryResponse;
-    'staged-quote': ctp.StagedQuotePagedQueryResponse;
-    'standalone-price': ctp.StandalonePricePagedQueryResponse;
-    state: ctp.StatePagedQueryResponse;
-    store: ctp.StorePagedQueryResponse;
-    subscription: ctp.SubscriptionPagedQueryResponse;
-    'tax-category': ctp.TaxCategoryPagedQueryResponse;
-    type: ctp.TypePagedQueryResponse;
-    zone: ctp.ZonePagedQueryResponse;
-};
-
-type QueryParams = {
-    expand?: string[];
-    where?: string[];
-    offset?: number;
-    limit?: number;
-    [key: string]: QueryParam;
-};
-type GetParams = {
-    expand?: string[];
-};
-type RepositoryContext = {
-    projectKey: string;
-    storeKey?: string;
-};
-declare abstract class AbstractRepository<R extends BaseResource | Project> {
-    protected _storage: AbstractStorage;
-    protected actions: Partial<Record<any, (context: RepositoryContext, resource: any, action: any) => void>>;
-    constructor(storage: AbstractStorage);
-    abstract saveNew({ projectKey }: RepositoryContext, resource: R): void;
-    abstract saveUpdate({ projectKey }: RepositoryContext, version: number, resource: R): void;
-    processUpdateActions(context: RepositoryContext, resource: R, version: number, actions: UpdateAction[]): R;
-    abstract postProcessResource(resource: any): any;
-}
-declare abstract class AbstractResourceRepository<T extends ResourceType> extends AbstractRepository<ResourceMap[T]> {
-    abstract create(context: RepositoryContext, draft: any): ResourceMap[T];
-    abstract getTypeId(): T;
-    constructor(storage: AbstractStorage);
-    postProcessResource(resource: ResourceMap[T]): ResourceMap[T];
-    query(context: RepositoryContext, params?: QueryParams): PagedQueryResponseMap[T];
-    get(context: RepositoryContext, id: string, params?: GetParams): ResourceMap[T] | null;
-    getByKey(context: RepositoryContext, key: string, params?: GetParams): ResourceMap[T] | null;
-    delete(context: RepositoryContext, id: string, params?: GetParams): ResourceMap[T] | null;
-    saveNew(context: RepositoryContext, resource: ShallowWritable<ResourceMap[T]>): void;
-    saveUpdate(context: RepositoryContext, version: number, resource: ShallowWritable<ResourceMap[T]>): ShallowWritable<ResourceMap[T]>;
-}
-
 declare class ProjectAPI {
     private projectKey;
     private _storage;
     private _repositories;
     constructor(projectKey: string, repositories: RepositoryMap, storage: AbstractStorage);
     add<T extends keyof RepositoryMap & keyof ResourceMap>(typeId: T, resource: ResourceMap[T]): void;
-    get<RT extends ResourceType>(typeId: RT, id: string, params?: GetParams): ResourceMap[RT];
+    get<RT extends ResourceType>(typeId: RT, id: string, params?: GetParams$1): ResourceMap[RT];
     getRepository<RT extends keyof RepositoryMap>(typeId: RT): RepositoryMap[RT];
 }