@labdigital/commercetools-mock 0.14.0 → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,585 @@
+import express from 'express';
+import * as ctp from '@commercetools/platform-sdk';
+import { Project, ResourceIdentifier, QueryParam, CartDraft, Cart, CartAddLineItemAction, CartRemoveLineItemAction, CartSetBillingAddressAction, CartSetShippingMethodAction, CartSetCountryAction, CartSetCustomerEmailAction, CartSetCustomFieldAction, CartSetCustomTypeAction, CartSetLocaleAction, CartSetShippingAddressAction, LineItemDraft, LineItem, CartDiscountDraft, CartDiscount, CartDiscountUpdateAction, CategoryDraft, Category, CategoryChangeAssetNameAction, CategoryChangeSlugAction, CategorySetKeyAction, CategorySetAssetDescriptionAction, CategorySetAssetSourcesAction, CategorySetDescriptionAction, CategorySetMetaDescriptionAction, CategorySetMetaKeywordsAction, CategorySetMetaTitleAction, CategorySetCustomTypeAction, CategorySetCustomFieldAction, ChannelDraft, Channel, ChannelUpdateAction, CustomObjectDraft, CustomObject, CustomerDraft, Customer, CustomerChangeEmailAction, CustomerSetAuthenticationModeAction, CustomerGroupDraft, CustomerGroup, CustomerGroupSetKeyAction, CustomerGroupChangeNameAction, CustomerGroupSetCustomTypeAction, CustomerGroupSetCustomFieldAction, DiscountCodeDraft, DiscountCode, DiscountCodeUpdateAction, Extension, ExtensionDraft, ExtensionUpdateAction, InventoryEntryDraft, InventoryEntry, InventoryEntryChangeQuantityAction, InventoryEntrySetExpectedDeliveryAction, InventoryEntrySetCustomFieldAction, InventoryEntrySetCustomTypeAction, InventoryEntrySetRestockableInDaysAction, OrderFromCartDraft, Order, CartReference, OrderImportDraft, OrderAddPaymentAction, OrderChangeOrderStateAction, OrderChangePaymentStateAction, OrderTransitionStateAction, OrderSetBillingAddressAction, OrderSetCustomerEmailAction, OrderSetCustomFieldAction, OrderSetCustomTypeAction, OrderSetLocaleAction, OrderSetOrderNumberAction, OrderSetShippingAddressAction, OrderSetStoreAction, MyOrderFromCartDraft, OrderEditDraft, OrderEdit, OrderEditUpdateAction, PaymentDraft, Payment, TransactionDraft, PaymentSetCustomFieldAction, PaymentSetCustomTypeAction, PaymentAddTransactionAction, PaymentChangeTransactionStateAction, PaymentTransitionStateAction, ProductDraft, Product, ProductUpdateAction, ProductDiscountDraft, ProductDiscount, ProductDiscountUpdateAction, ProductProjectionPagedSearchResponse, ProductProjection, FacetResults, TermFacetResult, FilteredFacetResult, RangeFacetResult, ProductSelectionDraft, ProductSelection, ReviewUpdateAction, Review, ProductTypeDraft, ProductType, AttributeDefinitionDraft, AttributeDefinition, ProductTypeUpdateAction, ProjectUpdateAction, QuoteDraft, Quote, QuoteUpdateAction, QuoteRequestDraft, QuoteRequest, QuoteRequestUpdateAction, ReviewDraft, ShippingMethodDraft, ShippingMethod, ShippingMethodUpdateAction, ShoppingListDraft, ShoppingList, 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 { ParsedQs } from 'qs';
+
+declare type GetParams$1 = {
+    expand?: string[];
+};
+declare type QueryParams$1 = {
+    expand?: string | string[];
+    sort?: string | string[];
+    limit?: number;
+    offset?: number;
+    withTotal?: boolean;
+    where?: string | string[];
+    [key: string]: QueryParam;
+};
+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 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 getByResourceIdentifier<RT extends ResourceType>(projectKey: string, identifier: ResourceIdentifier): ResourceMap[RT] | null;
+    abstract expand<T>(projectKey: string, obj: T, clause: undefined | string | string[]): T;
+}
+
+declare class CartRepository extends AbstractResourceRepository<'cart'> {
+    getTypeId(): "cart";
+    create(context: RepositoryContext, draft: CartDraft): Cart;
+    getActiveCart(projectKey: string): Cart | undefined;
+    actions: {
+        addLineItem: (context: RepositoryContext, resource: Writable<Cart>, { productId, variantId, sku, quantity }: CartAddLineItemAction) => 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;
+        setCustomType: (context: RepositoryContext, resource: Writable<Cart>, { type, fields }: CartSetCustomTypeAction) => void;
+        setLocale: (context: RepositoryContext, resource: Writable<Cart>, { locale }: CartSetLocaleAction) => void;
+        setShippingAddress: (context: RepositoryContext, resource: Writable<Cart>, { address }: CartSetShippingAddressAction) => void;
+    };
+    draftLineItemtoLineItem: (projectKey: string, draftLineItem: LineItemDraft, currency: string, country: string | undefined) => LineItem;
+}
+
+declare class CartDiscountRepository extends AbstractResourceRepository<'cart-discount'> {
+    getTypeId(): "cart-discount";
+    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";
+    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;
+        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;
+    };
+}
+
+declare class ChannelRepository extends AbstractResourceRepository<'channel'> {
+    getTypeId(): "channel";
+    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";
+    create(context: RepositoryContext, draft: Writable<CustomObjectDraft>): CustomObject;
+    getWithContainerAndKey(context: RepositoryContext, container: string, key: string): CustomObject | undefined;
+}
+
+declare class CustomerRepository extends AbstractResourceRepository<'customer'> {
+    getTypeId(): "customer";
+    create(context: RepositoryContext, draft: CustomerDraft): Customer;
+    getMe(context: RepositoryContext): Customer | undefined;
+    actions: {
+        changeEmail: (_context: RepositoryContext, resource: Writable<Customer>, { email }: CustomerChangeEmailAction) => void;
+        setAuthenticationMode: (_context: RepositoryContext, resource: Writable<Customer>, { authMode, password }: CustomerSetAuthenticationModeAction) => void;
+    };
+}
+
+declare class CustomerGroupRepository extends AbstractResourceRepository<'customer-group'> {
+    getTypeId(): "customer-group";
+    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";
+    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;
+    create(context: RepositoryContext, draft: ExtensionDraft): Extension;
+    actions: Record<ExtensionUpdateAction['action'], (context: RepositoryContext, resource: Writable<Extension>, action: any) => void>;
+}
+
+declare class InventoryEntryRepository extends AbstractResourceRepository<'inventory-entry'> {
+    getTypeId(): "inventory-entry";
+    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";
+    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;
+        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;
+    };
+}
+
+declare class MyOrderRepository extends OrderRepository {
+    create(context: RepositoryContext, draft: MyOrderFromCartDraft): Order;
+}
+
+declare class OrderEditRepository extends AbstractResourceRepository<'order-edit'> {
+    getTypeId(): "order-edit";
+    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";
+    create(context: RepositoryContext, draft: PaymentDraft): Payment;
+    transactionFromTransactionDraft: (draft: TransactionDraft, context: RepositoryContext) => {
+        id: string;
+        amount: ctp.TypedMoney;
+        custom: ctp.CustomFields | undefined;
+        timestamp?: string | undefined;
+        type: ctp.TransactionType;
+        interactionId?: string | undefined;
+        state?: ctp.TransactionState | undefined;
+    };
+    actions: {
+        setCustomField: (context: RepositoryContext, resource: Payment, { name, value }: PaymentSetCustomFieldAction) => void;
+        setCustomType: (context: RepositoryContext, resource: Writable<Payment>, { type, fields }: PaymentSetCustomTypeAction) => void;
+        addTransaction: (context: RepositoryContext, resource: Writable<Payment>, { transaction }: PaymentAddTransactionAction) => void;
+        changeTransactionState: (_context: RepositoryContext, resource: Writable<Payment>, { transactionId, state }: PaymentChangeTransactionStateAction) => void;
+        transitionState: (context: RepositoryContext, resource: Writable<Payment>, { state }: PaymentTransitionStateAction) => void;
+    };
+}
+
+declare class ProductRepository extends AbstractResourceRepository<'product'> {
+    getTypeId(): "product";
+    create(context: RepositoryContext, draft: ProductDraft): Product;
+    actions: Partial<Record<ProductUpdateAction['action'], (context: RepositoryContext, resource: Writable<Product>, action: any) => void>>;
+}
+
+declare class ProductDiscountRepository extends AbstractResourceRepository<'product-discount'> {
+    getTypeId(): "product-discount";
+    create(context: RepositoryContext, draft: ProductDiscountDraft): ProductDiscount;
+    private transformValueDraft;
+    actions: Partial<Record<ProductDiscountUpdateAction['action'], (context: RepositoryContext, resource: Writable<ProductDiscount>, action: any) => void>>;
+}
+
+/**
+ * This module implements the commercetools product projection filter expression.
+ */
+
+declare type RangeExpression = {
+    type: 'RangeExpression';
+    start?: number;
+    stop?: number;
+    match: (obj: any) => boolean;
+};
+declare type FilterExpression = {
+    type: 'FilterExpression';
+    match: (obj: any) => boolean;
+};
+
+declare 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[];
+    [key: string]: QueryParam;
+};
+declare class ProductProjectionSearch {
+    protected _storage: AbstractStorage;
+    constructor(storage: AbstractStorage);
+    search(projectKey: string, params: ProductProjectionSearchParams): ProductProjectionPagedSearchResponse;
+    transform(product: Product, staged: boolean): ProductProjection;
+    getFacets(params: ProductProjectionSearchParams, products: ProductProjection[]): FacetResults;
+    /**
+     * TODO: This implemention needs the following additional features:
+     *  - counting products
+     *  - correct dataType
+     */
+    termFacet(facet: string, products: ProductProjection[]): TermFacetResult;
+    filterFacet(source: string, filters: FilterExpression[] | undefined, products: ProductProjection[]): FilteredFacetResult;
+    rangeFacet(source: string, ranges: RangeExpression[] | undefined, products: ProductProjection[]): RangeFacetResult;
+}
+
+declare class ProductProjectionRepository extends AbstractResourceRepository<'product-projection'> {
+    protected _searchService: ProductProjectionSearch;
+    constructor(storage: AbstractStorage);
+    getTypeId(): "product-projection";
+    create(context: RepositoryContext, draft: ProductDraft): ProductProjection;
+    query(context: RepositoryContext, params?: QueryParams): {
+        results: ProductProjection[];
+        limit: number;
+        offset: number;
+        count: number;
+        total?: number | undefined;
+    };
+    search(context: RepositoryContext, query: ParsedQs): ctp.ProductProjectionPagedSearchResponse;
+    actions: {};
+}
+
+declare class ProductSelectionRepository extends AbstractResourceRepository<'product-selection'> {
+    getTypeId(): "product-selection";
+    create(context: RepositoryContext, draft: ProductSelectionDraft): ProductSelection;
+    actions: Partial<Record<ReviewUpdateAction['action'], (context: RepositoryContext, resource: Writable<Review>, action: any) => void>>;
+}
+
+declare class ProductTypeRepository extends AbstractResourceRepository<'product-type'> {
+    getTypeId(): "product-type";
+    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> {
+    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";
+    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";
+    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";
+    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";
+    create(context: RepositoryContext, draft: ShippingMethodDraft): ShippingMethod;
+    private _transformZoneRateDraft;
+    private _transformShippingRate;
+    actions: Partial<Record<ShippingMethodUpdateAction['action'], (context: RepositoryContext, resource: Writable<ShippingMethod>, action: any) => void>>;
+}
+
+declare class ShoppingListRepository extends AbstractResourceRepository<'shopping-list'> {
+    getTypeId(): "shopping-list";
+    create(context: RepositoryContext, draft: ShoppingListDraft): ShoppingList;
+}
+
+declare class StagedQuoteRepository extends AbstractResourceRepository<'staged-quote'> {
+    getTypeId(): "staged-quote";
+    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";
+    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";
+    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";
+    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";
+    create(context: RepositoryContext, draft: SubscriptionDraft): Subscription;
+}
+
+declare class TaxCategoryRepository extends AbstractResourceRepository<'tax-category'> {
+    getTypeId(): "tax-category";
+    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";
+    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";
+    create(context: RepositoryContext, draft: ZoneDraft): Zone;
+    actions: Partial<Record<ZoneUpdateAction['action'], (context: RepositoryContext, resource: Writable<Zone>, action: any) => void>>;
+}
+
+declare type RepositoryMap = ReturnType<typeof createRepositories>;
+declare const createRepositories: (storage: AbstractStorage) => {
+    category: CategoryRepository;
+    cart: CartRepository;
+    'cart-discount': CartDiscountRepository;
+    customer: CustomerRepository;
+    channel: ChannelRepository;
+    'customer-group': CustomerGroupRepository;
+    'discount-code': DiscountCodeRepository;
+    extension: ExtensionRepository;
+    'inventory-entry': InventoryEntryRepository;
+    'key-value-document': CustomObjectRepository;
+    order: OrderRepository;
+    'order-edit': OrderEditRepository;
+    payment: PaymentRepository;
+    'my-cart': CartRepository;
+    'my-order': MyOrderRepository;
+    'my-customer': CustomerRepository;
+    'my-payment': PaymentRepository;
+    product: ProductRepository;
+    '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;
+    state: StateRepository;
+    store: StoreRepository;
+    subscription: SubscriptionRepository;
+    'tax-category': TaxCategoryRepository;
+    type: TypeRepository;
+    zone: ZoneRepository;
+};
+
+declare type Writable<T> = {
+    -readonly [P in keyof T]: Writable<T[P]>;
+};
+declare type ShallowWritable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+declare type ResourceType = keyof ResourceMap & keyof RepositoryMap;
+declare type ResourceMap = {
+    '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;
+};
+declare type PagedQueryResponseMap = {
+    '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;
+};
+
+declare type QueryParams = {
+    expand?: string[];
+    where?: string[];
+    offset?: number;
+    limit?: number;
+};
+declare type GetParams = {
+    expand?: string[];
+};
+declare 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];
+    getRepository<RT extends keyof RepositoryMap>(typeId: RT): RepositoryMap[RT];
+}
+
+declare type CommercetoolsMockOptions = {
+    validateCredentials: boolean;
+    enableAuthentication: boolean;
+    defaultProjectKey: string | undefined;
+    apiHost: RegExp | string;
+    authHost: RegExp | string;
+    silent: boolean;
+};
+declare type AppOptions = {
+    silent?: boolean;
+};
+declare class CommercetoolsMock {
+    app: express.Express;
+    options: CommercetoolsMockOptions;
+    private _storage;
+    private _oauth2;
+    private _nockScopes;
+    private _services;
+    private _repositories;
+    private _projectService?;
+    constructor(options?: Partial<CommercetoolsMockOptions>);
+    start(): void;
+    stop(): void;
+    clear(): void;
+    project(projectKey?: string): ProjectAPI;
+    runServer(port?: number, options?: AppOptions): void;
+    private createApp;
+    private mockApiHost;
+    private mockAuthHost;
+}
+
+declare const getBaseResourceProperties: () => {
+    id: string;
+    createdAt: string;
+    lastModifiedAt: string;
+    version: number;
+};
+
+export { CommercetoolsMock, CommercetoolsMockOptions, getBaseResourceProperties };