@labdigital/commercetools-mock 0.10.0 → 0.11.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import express, { Router, Request, Response } from 'express';
+import express from 'express';
 import * as ctp from '@commercetools/platform-sdk';
-import { Project, BaseResource, PagedQueryResponse, ResourceIdentifier, QueryParam, ProductProjectionPagedSearchResponse, Product, ProductProjection, FacetResults, TermFacetResult, FilteredFacetResult, RangeFacetResult, ProductDraft, ReferenceTypeId, ShoppingListDraft, ShoppingList, CartDraft, Cart, CartAddLineItemAction, CartRemoveLineItemAction, CartSetBillingAddressAction, CartSetShippingMethodAction, CartSetCountryAction, CartSetCustomerEmailAction, CartSetCustomFieldAction, CartSetCustomTypeAction, CartSetLocaleAction, CartSetShippingAddressAction, LineItemDraft, LineItem, CustomerDraft, Customer, CustomerChangeEmailAction, CustomerSetAuthenticationModeAction, CustomObjectDraft, CustomObject, InventoryEntryDraft, InventoryEntry, InventoryEntryChangeQuantityAction, InventoryEntrySetExpectedDeliveryAction, InventoryEntrySetCustomFieldAction, InventoryEntrySetCustomTypeAction, InventoryEntrySetRestockableInDaysAction, OrderFromCartDraft, Order, CartReference, OrderImportDraft, OrderAddPaymentAction, OrderChangeOrderStateAction, OrderChangePaymentStateAction, OrderTransitionStateAction, OrderSetBillingAddressAction, OrderSetCustomerEmailAction, OrderSetCustomFieldAction, OrderSetCustomTypeAction, OrderSetLocaleAction, OrderSetOrderNumberAction, OrderSetShippingAddressAction, OrderSetStoreAction, PaymentDraft, Payment, TransactionDraft, PaymentSetCustomFieldAction, PaymentSetCustomTypeAction, PaymentAddTransactionAction, PaymentChangeTransactionStateAction, PaymentTransitionStateAction, ProductUpdateAction, ProductTypeDraft, ProductType, AttributeDefinitionDraft, AttributeDefinition, ProductTypeUpdateAction, ShippingMethodDraft, ShippingMethod, ShippingMethodUpdateAction, StateDraft, State, StateUpdateAction, TaxCategoryDraft, TaxCategory, TaxCategoryUpdateAction, ProductDiscountDraft, ProductDiscount, ProductDiscountUpdateAction, UpdateAction } 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, StandalonePrice, StandalonePriceUpdateAction, 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 = {
@@ -17,108 +17,21 @@ declare type QueryParams$1 = {
 };
 declare abstract class AbstractStorage {
     abstract clear(): void;
-    abstract all<RT extends RepositoryTypes>(projectKey: string, typeId: RT): Array<ResourceMap[RT]>;
-    abstract add<RT extends RepositoryTypes>(projectKey: string, typeId: RT, obj: ResourceMap[RT]): void;
-    abstract get<RT extends RepositoryTypes>(projectKey: string, typeId: RT, id: string, params?: GetParams$1): ResourceMap[RT] | null;
-    abstract getByKey<RT extends RepositoryTypes>(projectKey: string, typeId: RT, key: string, params: GetParams$1): ResourceMap[RT] | null;
+    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 RepositoryTypes>(projectKey: string, typeId: RT, id: string, params: GetParams$1): BaseResource | null;
-    abstract query(projectKey: string, typeId: RepositoryTypes, params: QueryParams$1): PagedQueryResponse;
-    abstract getByResourceIdentifier<RT extends RepositoryTypes>(projectKey: string, identifier: ResourceIdentifier): ResourceMap[RT] | undefined;
+    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;
 }
 
-/**
- * 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 | null;
-    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 {
-    protected _searchService: ProductProjectionSearch;
-    constructor(storage: AbstractStorage);
-    getTypeId(): RepositoryTypes;
-    create(context: RepositoryContext, draft: ProductDraft): ProductProjection;
-    query(context: RepositoryContext, params?: QueryParams): ctp.PagedQueryResponse;
-    search(context: RepositoryContext, query: ParsedQs): ctp.ProductProjectionPagedSearchResponse;
-    actions: {};
-}
-
-declare class ShoppingListRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
-    create(context: RepositoryContext, draft: ShoppingListDraft): ShoppingList;
-}
-
-declare abstract class AbstractService {
-    protected abstract getBasePath(): string;
-    abstract repository: AbstractResourceRepository;
-    createStatusCode: number;
-    constructor(parent: Router);
-    extraRoutes(router: Router): void;
-    registerRoutes(parent: Router): void;
-    get(request: Request, response: Response): Response<any, Record<string, any>>;
-    getWithId(request: Request, response: Response): Response<any, Record<string, any>>;
-    getWithKey(request: Request, response: Response): Response<any, Record<string, any>>;
-    deleteWithId(request: Request, response: Response): Response<any, Record<string, any>>;
-    deleteWithKey(request: Request, response: Response): Response<any, Record<string, any>>;
-    post(request: Request, response: Response): Response<any, Record<string, any>>;
-    postWithId(request: Request, response: Response): Response<any, Record<string, any>>;
-    postWithKey(request: Request, response: Response): Response<any, Record<string, any>>;
-    protected _expandWithId(request: Request, resourceId: string): ctp.BaseResource | null;
-    private _parseParam;
-}
-
-declare class CartRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+declare class CartRepository extends AbstractResourceRepository<'cart'> {
+    getTypeId(): "cart";
     create(context: RepositoryContext, draft: CartDraft): Cart;
     getActiveCart(projectKey: string): Cart | undefined;
     actions: {
@@ -136,8 +49,45 @@ declare class CartRepository extends AbstractResourceRepository {
     draftLineItemtoLineItem: (projectKey: string, draftLineItem: LineItemDraft, currency: string, country: string | undefined) => LineItem;
 }
 
-declare class CustomerRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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: {
@@ -146,14 +96,32 @@ declare class CustomerRepository extends AbstractResourceRepository {
     };
 }
 
-declare class CustomObjectRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
-    create(context: RepositoryContext, draft: Writable<CustomObjectDraft>): CustomObject;
-    getWithContainerAndKey(context: RepositoryContext, container: string, key: string): CustomObject | undefined;
+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 InventoryEntryRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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;
@@ -164,8 +132,8 @@ declare class InventoryEntryRepository extends AbstractResourceRepository {
     };
 }
 
-declare class OrderRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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;
@@ -188,8 +156,18 @@ declare class OrderRepository extends AbstractResourceRepository {
     };
 }
 
-declare class PaymentRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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;
@@ -209,82 +187,264 @@ declare class PaymentRepository extends AbstractResourceRepository {
     };
 }
 
-declare class ProductRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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 ProductTypeRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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;
-    getWithKey(context: RepositoryContext, key: string): ProductType | undefined;
     actions: Partial<Record<ProductTypeUpdateAction['action'], (context: RepositoryContext, resource: Writable<ProductType>, action: any) => void>>;
 }
 
-declare class ShippingMethodRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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 StateRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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: StandalonePrice): StandalonePrice;
+    actions: Partial<Record<StandalonePriceUpdateAction['action'], (context: RepositoryContext, resource: Writable<Review>, action: any) => 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 TaxCategoryRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
+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;
-    getWithKey(context: RepositoryContext, key: string): TaxCategory | undefined;
     actions: Partial<Record<TaxCategoryUpdateAction['action'], (context: RepositoryContext, resource: Writable<TaxCategory>, action: any) => void>>;
 }
 
-declare class ProductDiscountRepository extends AbstractResourceRepository {
-    getTypeId(): ReferenceTypeId;
-    create(context: RepositoryContext, draft: ProductDiscountDraft): ProductDiscount;
-    private transformValueDraft;
-    getWithKey(context: RepositoryContext, key: string): ProductDiscount | undefined;
-    actions: Partial<Record<ProductDiscountUpdateAction['action'], (context: RepositoryContext, resource: Writable<ProductDiscount>, 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 RepositoryTypes = ReferenceTypeId | 'standalone-price' | 'product-projection';
-declare type ServiceTypes = RepositoryTypes | 'my-cart' | 'my-order' | 'my-payment' | 'my-customer' | 'product-projection';
-declare type Services = Partial<{
-    [index in ServiceTypes]: AbstractService;
-}>;
-declare type Resource = ctp.BaseResource | ctp.Cart | ctp.CartDiscount | ctp.Category | ctp.Channel | ctp.Customer | ctp.CustomerGroup | ctp.DiscountCode | ctp.Extension | ctp.InventoryEntry | ctp.CustomObject | ctp.Order | ctp.OrderEdit | ctp.Payment | ctp.Product | ctp.Project | ctp.ProductDiscount | ctp.ProductProjection | ctp.ProductSelection | ctp.StandalonePrice | ctp.ProductType | ctp.Review | ctp.ShippingMethod | ctp.ShoppingList | ctp.StandalonePrice | ctp.State | ctp.Store | ctp.Subscription | ctp.TaxCategory | ctp.Type | ctp.Zone;
+declare type ShallowWritable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+declare type ResourceType = keyof ResourceMap & keyof RepositoryMap;
 declare type ResourceMap = {
-    cart: ctp.Cart;
     'cart-discount': ctp.CartDiscount;
+    cart: ctp.Cart;
     category: ctp.Category;
     channel: ctp.Channel;
-    customer: ctp.Customer;
+    '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: ctp.Order;
     'order-edit': ctp.OrderEdit;
+    order: ctp.Order;
     payment: ctp.Payment;
-    product: ctp.Product;
     'product-discount': ctp.ProductDiscount;
+    'product-price': ctp.StandalonePrice;
     'product-projection': ctp.ProductProjection;
     'product-selection': ctp.ProductSelection;
-    'product-price': ctp.StandalonePrice;
     '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;
@@ -292,38 +452,42 @@ declare type ResourceMap = {
     'tax-category': ctp.TaxCategory;
     type: ctp.Type;
     zone: ctp.Zone;
-    'customer-email-token': never;
-    'customer-password-token': never;
 };
-declare type RepositoryMap = {
-    cart: CartRepository;
-    'cart-discount': never;
-    category: never;
-    channel: never;
-    customer: CustomerRepository;
+declare type PagedQueryResponseMap = {
+    'cart-discount': ctp.CartDiscountPagedQueryResponse;
+    cart: ctp.CartPagedQueryResponse;
+    category: ctp.CategoryPagedQueryResponse;
+    channel: ctp.ChannelPagedQueryResponse;
     'customer-email-token': never;
-    'customer-group': never;
+    'customer-group': ctp.CustomerGroupPagedQueryResponse;
     'customer-password-token': never;
-    'discount-code': never;
-    extension: never;
-    'inventory-entry': InventoryEntryRepository;
-    'key-value-document': CustomObjectRepository;
-    order: OrderRepository;
-    'order-edit': never;
-    payment: PaymentRepository;
-    product: ProductRepository;
-    'product-projection': ProductProjectionRepository;
-    'product-discount': ProductDiscountRepository;
-    'product-type': ProductTypeRepository;
-    review: never;
-    'shipping-method': ShippingMethodRepository;
-    'shopping-list': ShoppingListRepository;
-    state: StateRepository;
-    store: never;
-    subscription: never;
-    'tax-category': TaxCategoryRepository;
-    type: ctp.Type;
-    zone: ctp.Zone;
+    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 = {
@@ -339,35 +503,36 @@ declare type RepositoryContext = {
     projectKey: string;
     storeKey?: string;
 };
-declare abstract class AbstractRepository {
+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: Resource): void;
-    abstract saveUpdate({ projectKey }: RepositoryContext, version: number, resource: Resource): void;
-    processUpdateActions<T extends Resource>(context: RepositoryContext, resource: T, version: number, actions: UpdateAction[]): T;
-    postProcessResource<T extends Resource>(resource: T): T;
-}
-declare abstract class AbstractResourceRepository extends AbstractRepository {
-    abstract create(context: RepositoryContext, draft: any): BaseResource;
-    abstract getTypeId(): RepositoryTypes;
+    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);
-    query(context: RepositoryContext, params?: QueryParams): ctp.PagedQueryResponse;
-    get(context: RepositoryContext, id: string, params?: GetParams): BaseResource | null;
-    getByKey(context: RepositoryContext, key: string, params?: GetParams): BaseResource | null;
-    delete(context: RepositoryContext, id: string, params?: GetParams): BaseResource | null;
-    saveNew(context: RepositoryContext, resource: Writable<BaseResource>): void;
-    saveUpdate(context: RepositoryContext, version: number, resource: Writable<BaseResource>): Writable<BaseResource>;
+    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 _services;
-    constructor(projectKey: string, services: Services, storage: AbstractStorage);
-    add(typeId: ReferenceTypeId, resource: ResourceMap[ReferenceTypeId]): void;
-    get<RT extends RepositoryTypes>(typeId: RT, id: string, params?: GetParams): ResourceMap[RT];
-    getRepository<RT extends keyof RepositoryMap>(typeId: ServiceTypes): RepositoryMap[RT];
+    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 = {