@labdigital/commercetools-mock 2.42.0 → 2.43.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import express from 'express';
 import { SetupServerApi, SetupServer } from 'msw/node';
 import * as ctp from '@commercetools/platform-sdk';
-import { Project, ResourceIdentifier, QueryParam, BaseResource, UpdateAction, ProductTailoring, CartDraft, Cart, LineItemDraft, LineItem, OrderFromCartDraft, Order, CartReference, OrderImportDraft, AssociateRoleDraft, AssociateRole, AttributeGroupDraft, AttributeGroup, BusinessUnitDraft, BusinessUnit, CartDiscountDraft, CartDiscount, CategoryDraft, Category, ChannelDraft, Channel, CustomObjectDraft, CustomObject, CustomerDraft, Customer, CustomerCreatePasswordResetToken, CustomerToken, CustomerResetPassword, MyCustomerResetPassword, CustomerGroupDraft, CustomerGroup, DiscountCodeDraft, DiscountCode, ExtensionDraft, Extension, InventoryEntryDraft, InventoryEntry, MyCustomerChangePassword, MyCustomerEmailVerify, MyOrderFromCartDraft, OrderEditDraft, OrderEdit, PaymentDraft, Payment, ProductSearchRequest, ProductPagedSearchResponse, Product, ProductProjection, ProductDraft, ProductDiscountDraft, ProductDiscount, ProductProjectionPagedSearchResponse, 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';
+import { QueryParam, BaseResource, Project, UpdateAction, ProductTailoring, CartDraft, Cart, LineItemDraft, LineItem, OrderFromCartDraft, Order, CartReference, OrderImportDraft, AssociateRoleDraft, AssociateRole, AttributeGroupDraft, AttributeGroup, BusinessUnitDraft, BusinessUnit, CartDiscountDraft, CartDiscount, CategoryDraft, Category, ChannelDraft, Channel, CustomObjectDraft, CustomObject, CustomerDraft, Customer, CustomerCreatePasswordResetToken, CustomerToken, CustomerResetPassword, MyCustomerResetPassword, CustomerGroupDraft, CustomerGroup, DiscountCodeDraft, DiscountCode, ExtensionDraft, Extension, InventoryEntryDraft, InventoryEntry, MyCustomerChangePassword, MyCustomerEmailVerify, MyOrderFromCartDraft, OrderEditDraft, OrderEdit, PaymentDraft, Payment, ProductSearchRequest, ProductPagedSearchResponse, Product, ProductProjection, ProductDraft, ProductDiscountDraft, ProductDiscount, ProductProjectionPagedSearchResponse, 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, ResourceIdentifier } from '@commercetools/platform-sdk';
 
 type Token = {
     access_token: string;
@@ -27,129 +27,14 @@ declare class OAuth2Store {
     validateToken(token: string): boolean;
 }
 
-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-tailoring": ctp.ProductTailoring;
-    "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-tailoring": ctp.ProductTailoringPagedQueryResponse;
-    "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$1 = {
-    expand?: string[];
-};
 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]): ResourceMap[RT];
-    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];
-    abstract expand<T>(projectKey: string, obj: T, clause: undefined | string | string[]): T;
-}
-
-type QueryParams = {
     expand?: string[];
     where?: string[];
     offset?: number;
     limit?: number;
     [key: string]: QueryParam;
 };
-type GetParams = {
+type GetParams$1 = {
     expand?: string[];
 };
 type RepositoryContext = {
@@ -158,8 +43,9 @@ type RepositoryContext = {
 };
 declare abstract class AbstractRepository<R extends BaseResource | Project> {
     protected _storage: AbstractStorage;
+    protected config: Config;
     protected actions: AbstractUpdateHandler | undefined;
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     abstract saveNew({ projectKey }: RepositoryContext, resource: R): void;
     abstract saveUpdate({ projectKey }: RepositoryContext, version: number, resource: R): void;
     abstract postProcessResource(context: RepositoryContext, resource: any): any;
@@ -167,14 +53,14 @@ declare abstract class AbstractRepository<R extends BaseResource | Project> {
 }
 declare abstract class AbstractResourceRepository<T extends ResourceType> extends AbstractRepository<ResourceMap[T]> {
     protected _typeId: T;
-    constructor(typeId: T, storage: AbstractStorage);
+    constructor(typeId: T, config: Config);
     abstract create(context: RepositoryContext, draft: any): ResourceMap[T];
     protected getTypeId(): T;
-    delete(context: RepositoryContext, id: string, params?: GetParams): ResourceMap[T] | null;
-    get(context: RepositoryContext, id: string, params?: GetParams): ResourceMap[T] | null;
-    getByKey(context: RepositoryContext, key: string, params?: GetParams): ResourceMap[T] | null;
-    postProcessResource(context: RepositoryContext, resource: ResourceMap[T], params?: GetParams): ResourceMap[T];
-    query(context: RepositoryContext, params?: QueryParams): PagedQueryResponseMap[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(context: RepositoryContext, resource: ResourceMap[T], params?: GetParams$1): ResourceMap[T];
+    query(context: RepositoryContext, params?: QueryParams$1): PagedQueryResponseMap[T] & {
         results: ResourceMap[T][];
     };
     saveNew(context: RepositoryContext, resource: ShallowWritable<ResourceMap[T]>): ResourceMap[T];
@@ -187,25 +73,25 @@ declare class AbstractUpdateHandler {
 }
 
 declare class ProductTailoringRepository extends AbstractResourceRepository<"product-tailoring"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: any): ProductTailoring;
 }
 
 declare class CartRepository extends AbstractResourceRepository<"cart"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: CartDraft): Cart;
     getActiveCart(projectKey: string): Cart | undefined;
     draftLineItemtoLineItem: (projectKey: string, draftLineItem: LineItemDraft, currency: string, country: string | undefined) => LineItem;
 }
 
 declare class OrderRepository extends AbstractResourceRepository<"order"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     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;
+    getWithOrderNumber(context: RepositoryContext, orderNumber: string, params?: QueryParams$1): Order | undefined;
 }
 
 declare class AsAssociateOrderRepository extends OrderRepository {
@@ -214,48 +100,48 @@ declare class AsAssociateCartRepository extends CartRepository {
 }
 
 declare class AssociateRoleRepository extends AbstractResourceRepository<"associate-role"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: AssociateRoleDraft): AssociateRole;
 }
 
 declare class AttributeGroupRepository extends AbstractResourceRepository<"attribute-group"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: AttributeGroupDraft): AttributeGroup;
 }
 
 declare class BusinessUnitRepository extends AbstractResourceRepository<"business-unit"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: BusinessUnitDraft): BusinessUnit;
     private _isCompanyDraft;
     private _isDivisionDraft;
 }
 
 declare class CartDiscountRepository extends AbstractResourceRepository<"cart-discount"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: CartDiscountDraft): CartDiscount;
     private transformValueDraft;
 }
 
 declare class CategoryRepository extends AbstractResourceRepository<"category"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: CategoryDraft): Category;
-    postProcessResource(context: RepositoryContext, resource: Writable<Category>, params?: GetParams): Category;
+    postProcessResource(context: RepositoryContext, resource: Writable<Category>, params?: GetParams$1): Category;
 }
 
 declare class ChannelRepository extends AbstractResourceRepository<"channel"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ChannelDraft): Channel;
 }
 
 declare class CustomObjectRepository extends AbstractResourceRepository<"key-value-document"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: Writable<CustomObjectDraft>): CustomObject;
     getWithContainerAndKey(context: RepositoryContext, container: string, key: string): CustomObject | undefined;
-    queryWithContainer(context: RepositoryContext, container: string, params?: QueryParams): ctp.CustomObjectPagedQueryResponse;
+    queryWithContainer(context: RepositoryContext, container: string, params?: QueryParams$1): ctp.CustomObjectPagedQueryResponse;
 }
 
 declare class CustomerRepository extends AbstractResourceRepository<"customer"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: CustomerDraft): Customer;
     saveUpdate(context: RepositoryContext, version: number, resource: ShallowWritable<ResourceMap["customer"]>): ShallowWritable<ResourceMap["customer"]>;
     passwordResetToken(context: RepositoryContext, request: CustomerCreatePasswordResetToken): CustomerToken;
@@ -265,23 +151,23 @@ declare class CustomerRepository extends AbstractResourceRepository<"customer">
 }
 
 declare class CustomerGroupRepository extends AbstractResourceRepository<"customer-group"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: CustomerGroupDraft): CustomerGroup;
 }
 
 declare class DiscountCodeRepository extends AbstractResourceRepository<"discount-code"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: DiscountCodeDraft): DiscountCode;
 }
 
 declare class ExtensionRepository extends AbstractResourceRepository<"extension"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ExtensionDraft): Extension;
     postProcessResource(context: RepositoryContext, resource: Extension): Extension;
 }
 
 declare class InventoryEntryRepository extends AbstractResourceRepository<"inventory-entry"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: InventoryEntryDraft): InventoryEntry;
 }
 
@@ -297,31 +183,31 @@ declare class MyOrderRepository extends OrderRepository {
 }
 
 declare class OrderEditRepository extends AbstractResourceRepository<"order-edit"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: OrderEditDraft): OrderEdit;
 }
 
 declare class PaymentRepository extends AbstractResourceRepository<"payment"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: PaymentDraft): Payment;
 }
 
 declare class ProductSearch {
     protected _storage: AbstractStorage;
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     search(projectKey: string, params: ProductSearchRequest): ProductPagedSearchResponse;
     transform(product: Product, staged: boolean): ProductProjection;
 }
 
 declare class ProductRepository extends AbstractResourceRepository<"product"> {
     protected _searchService: ProductSearch;
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ProductDraft): Product;
     search(context: RepositoryContext, searchRequest: ProductSearchRequest): ProductPagedSearchResponse;
 }
 
 declare class ProductDiscountRepository extends AbstractResourceRepository<"product-discount"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ProductDiscountDraft): ProductDiscount;
 }
 
@@ -364,7 +250,7 @@ type ProductProjectionSearchParams = {
 };
 declare class ProductProjectionSearch {
     protected _storage: AbstractStorage;
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     search(projectKey: string, params: ProductProjectionSearchParams): ProductProjectionPagedSearchResponse;
     transform(product: Product, staged: boolean): ProductProjection;
     getFacets(params: ProductProjectionSearchParams, products: ProductProjection[]): FacetResults;
@@ -396,9 +282,9 @@ type ProductProjectionQueryParams = {
 };
 declare class ProductProjectionRepository extends AbstractResourceRepository<"product-projection"> {
     protected _searchService: ProductProjectionSearch;
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     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;
@@ -410,17 +296,17 @@ declare class ProductProjectionRepository extends AbstractResourceRepository<"pr
 }
 
 declare class ProductSelectionRepository extends AbstractResourceRepository<"product-selection"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ProductSelectionDraft): ProductSelection;
 }
 
 declare class ProductTypeRepository extends AbstractResourceRepository<"product-type"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ProductTypeDraft): ProductType;
 }
 
 declare class ProjectRepository extends AbstractRepository<Project> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     get(context: RepositoryContext): Project | null;
     postProcessResource(context: RepositoryContext, resource: Project): Project;
     saveNew(context: RepositoryContext, resource: Writable<Project>): void;
@@ -428,24 +314,24 @@ declare class ProjectRepository extends AbstractRepository<Project> {
 }
 
 declare class QuoteRepository extends AbstractResourceRepository<"quote"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: QuoteDraft): Quote;
 }
 
 declare class QuoteRequestRepository extends AbstractResourceRepository<"quote-request"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: QuoteRequestDraft): QuoteRequest;
 }
 
 declare class ReviewRepository extends AbstractResourceRepository<"review"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ReviewDraft): Review;
 }
 
 declare class ShippingMethodRepository extends AbstractResourceRepository<"shipping-method"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ShippingMethodDraft): ShippingMethod;
-    matchingCart(context: RepositoryContext, cartId: string, params?: GetParams): {
+    matchingCart(context: RepositoryContext, cartId: string, params?: GetParams$1): {
         results: {
             zoneRates: {
                 zone: ZoneReference;
@@ -477,54 +363,54 @@ declare class ShippingMethodRepository extends AbstractResourceRepository<"shipp
 }
 
 declare class ShoppingListRepository extends AbstractResourceRepository<"shopping-list"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ShoppingListDraft): ShoppingList;
     draftLineItemtoLineItem: (projectKey: string, draftLineItem: LineItemDraft) => ShoppingListLineItem;
 }
 
 declare class StagedQuoteRepository extends AbstractResourceRepository<"staged-quote"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: StagedQuoteDraft): StagedQuote;
 }
 
 declare class StandAlonePriceRepository extends AbstractResourceRepository<"standalone-price"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: StandalonePriceDraft): StandalonePrice;
     transformChannelReferenceDraft(channel: ChannelResourceIdentifier): ChannelReference;
 }
 
 declare class StateRepository extends AbstractResourceRepository<"state"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: StateDraft): State;
 }
 
 declare class StoreRepository extends AbstractResourceRepository<"store"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: StoreDraft): Store;
 }
 
 declare class SubscriptionRepository extends AbstractResourceRepository<"subscription"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: SubscriptionDraft): Subscription;
 }
 
 declare class TaxCategoryRepository extends AbstractResourceRepository<"tax-category"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: TaxCategoryDraft): TaxCategory;
 }
 
 declare class TypeRepository extends AbstractResourceRepository<"type"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: TypeDraft): Type;
 }
 
 declare class ZoneRepository extends AbstractResourceRepository<"zone"> {
-    constructor(storage: AbstractStorage);
+    constructor(config: Config);
     create(context: RepositoryContext, draft: ZoneDraft): Zone;
 }
 
 type RepositoryMap = ReturnType<typeof createRepositories>;
-declare const createRepositories: (storage: AbstractStorage) => {
+declare const createRepositories: (config: Config) => {
     "as-associate": {
         cart: AsAssociateCartRepository;
         order: AsAssociateOrderRepository;
@@ -572,13 +458,135 @@ declare const createRepositories: (storage: AbstractStorage) => {
     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-tailoring": ctp.ProductTailoring;
+    "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-tailoring": ctp.ProductTailoringPagedQueryResponse;
+    "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;
+    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]): 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): 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;
+}
+
+type Config = {
+    strict: boolean;
+    storage: AbstractStorage;
+};
+
 declare class ProjectAPI {
     private projectKey;
     private _storage;
     private _repositories;
-    constructor(projectKey: string, repositories: RepositoryMap, storage: AbstractStorage);
+    private config;
+    constructor(projectKey: string, repositories: RepositoryMap, config: Config);
     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];
+    unsafeAdd<T extends keyof RepositoryMap & keyof ResourceMap>(typeId: T, resource: ResourceMap[T]): void;
+    get<RT extends ResourceType>(typeId: RT, id: string, params?: GetParams$1): ResourceMap[RT];
     getRepository<RT extends keyof RepositoryMap>(typeId: RT): RepositoryMap[RT];
 }
 
@@ -589,6 +597,7 @@ type CommercetoolsMockOptions = {
     apiHost: RegExp | string;
     authHost: RegExp | string;
     silent: boolean;
+    strict: boolean;
 };
 type AppOptions = {
     silent?: boolean;