addio-admin-sdk 1.6.5

package/dist/lib/Space/index.d.ts

@@ -0,0 +1,758 @@
+import IDeclination from '../../Interfaces/Declination';
+import ICart, { CartTypeEnum, IApplicablePromiseBank, ICartItem, IIndexedDeclination } from '../../Interfaces/Cart';
+import IQueryOptions from '../../Interfaces/Query/IProductQueryOptions';
+import ISpace, { IBlockedDates, ICurrencies, IDimensionUnit, IBucketDocument, IExternalServices, IFixedPromoBanner, IG2Calls, IPredefinedBox, IShippingRangeRestrictions, ISpaceOptions } from '../../Interfaces/Space';
+import IBrand from '../../Interfaces/Brand';
+import IProduct, { IQueryProps } from '../../Interfaces/Product';
+import IDiscountRule from '../../Interfaces/Rules/IDiscountRule';
+import ICustomer from '../../Interfaces/Customer';
+import IBrandQueryOptions from '../../Interfaces/Query/IBrandQueryOptions';
+import ICategoryQueryOptions from '../../Interfaces/Query/ICategoryQueryOptions';
+import ICategory from '../../Interfaces/Category';
+import IAttribute from '../../Interfaces/Attribute';
+import IClass from '../../Interfaces/Class';
+import IPurchaseOrder, { IOrderDeclination } from '../../Interfaces/PurchaseOrder';
+import ITax from '../../Interfaces/Tax';
+import IndexedProduct from '../Indexed/Product';
+import IIndexedProduct from '../../Interfaces/Indexed/Product';
+import Attribute from '../Attribute';
+import Class from '../Class';
+import Supplier from '../Supplier';
+import ExternalService from '../ExternalService';
+import PurchaseOrder from '../PurchaseOrder';
+import Invoice from '../Invoice';
+import BlogAuthor from '../Blog/BlogAuthor';
+import BlogCategory from '../Blog/BlogCategory';
+import BlogKeyword from '../Blog/BlogKeyword';
+import BlogArticle from '../Blog/BlogArticle';
+import Cart from '../Cart';
+import Product from '../Product';
+import Discount from '../Discount';
+import Customer from '../Customer';
+import Brand from '../Brand';
+import Category from '../Category';
+import Order from '../Order';
+import ITranslation from '../../Interfaces/Translation';
+import IStore from '../../Interfaces/Store';
+import Tag from '../Tags';
+import { InventoryPriorityTypeEnum } from '../../Interfaces/Inventory';
+import { IPriceRange } from '../../Interfaces/Algolia';
+import Booking from '../Booking';
+import IInventoryItem from '../../Interfaces/Product/IInventoryItem';
+import { TransferRequest } from '../TransferRequest';
+import Inventory from '../Inventory';
+import Catalogue from '../Catalogue';
+import ICatalogue from '../../Interfaces/Catalogue';
+import IUpdate from '../../Interfaces/Update';
+import IBGJob from '../../Interfaces/BGJob';
+import BGJob from '../BGJob';
+import { BankTypeAssociationEnum, IBankRule, IBankType } from '../../Interfaces/PromiseToPurchase/BankType';
+import PromiseToPurchase from '../PromiseToPurchase';
+import { SearchResponse } from '@algolia/client-search';
+import User from '../User';
+import IUser from '../../Interfaces/User/IUser';
+import IIndexedCustomerPromiseToPurchase from '../../Interfaces/PromiseToPurchase/IIndexedCustomerPromiseToPurchase';
+import Slider from '../Slider';
+import IIndexedBankUsed, { BankUpdateTypeEnum, IRemainingBankAmount } from '../../Interfaces/PromiseToPurchase/IIndexedBankUsed';
+import { IDatabaseRef, IRefObject } from '../../services/database/DatabaseService';
+import { ICustomPriceItem } from '../../Interfaces/G2';
+export default class Space {
+    private _space_ref;
+    private _user;
+    private _space;
+    private _currencies;
+    constructor(space: ISpace, user: string, space_ref: IRefObject);
+    getRef: () => IRefObject;
+    static getCurrentSpace: (childCollection: string, refUser: string) => Promise<Space>;
+    static getCurrentSpaceWithRef: (childCollection: string, refUser: string) => Promise<Space>;
+    initCurrencies: () => Promise<any>;
+    create: () => Promise<IDatabaseRef>;
+    update: (updates: Partial<ISpace>) => Promise<boolean>;
+    getDefaultTax: () => string | undefined;
+    getCurrencies: () => ICurrencies | undefined;
+    incrementOrderAndInvoiceRef: () => Promise<number>;
+    save: (partialSpace: Partial<ISpace>) => Promise<void>;
+    listenOnChange: (callback: any) => string;
+    private _getAllCustomerGroups;
+    private _updateShippingFee;
+    private _updateFreeShippingRestrictions;
+    private _updateFreeShippingRestrictionsValues;
+    private _getFreeShippingRestrictions;
+    private _disabledShipping;
+    private _getShippingAsProduct;
+    private _setShippingAsProduct;
+    private _disabledPickup;
+    private _getAllBlockedDates;
+    private _getBlockedDatesForCartType;
+    private _updateBlockedDates;
+    private _addNewBoxToShippingPref;
+    private _addNewProductToShippingPref;
+    private _addNewUnitToShippingPref;
+    private _deleteBoxToShippingPref;
+    private _deleteProductToShippingPref;
+    private _deleteUnitToShippingPref;
+    private _updateProductToShippingPref;
+    private _updateUnitToShippingPref;
+    private _updateBoxToShippingPref;
+    private _getProductToShippingPref;
+    private _getUnitToShippingPref;
+    private _getBoxToShippingPref;
+    private _addNewEnvelopToShippingPref;
+    private _deleteEnvelopToShippingPref;
+    private _updateEnvelopToShippingPref;
+    private _getEnvelopToShippingPref;
+    private _getAllProductPreferences;
+    private _getOptions;
+    private _saveOptions;
+    private _getAllStores;
+    private _addNewStore;
+    private _updateStore;
+    private _deleteStore;
+    private _getExternalServices;
+    callProductPublicService: (service: any, value: string, fromServer?: boolean) => Promise<{
+        confirmed: boolean;
+        details: any;
+        error?: undefined;
+    } | {
+        confirmed: boolean;
+        error: unknown;
+        details?: undefined;
+    }>;
+    private _fetchServices;
+    private _getAllTaxes;
+    private _getTaxes;
+    private _getMostRecentConsentForm;
+    private _brandsListener;
+    private _getBrands;
+    updateBrand: (partial: Partial<IBrand>, brand: IBrand) => Promise<void>;
+    addBrand: (brand: Partial<IBrand>) => Promise<string | boolean | undefined>;
+    private _getBlogArticles;
+    private _getBlogAuthors;
+    private _getBlogCategories;
+    private _blogCategoriesListener;
+    private _getBlogKeywords;
+    _getCatalogues: () => Promise<Catalogue[]>;
+    _getCatalogueById: (id: string) => Promise<Catalogue | undefined>;
+    _checkIfCatalogueSlugIsUnique: (slug: string, id: string) => Promise<boolean>;
+    _saveCatalogue: (catalogue: ICatalogue) => Promise<string | boolean>;
+    _deleteCataloguesById: (ids: string[]) => Promise<boolean>;
+    private _categoriesListener;
+    private _getCategories;
+    private _getTree;
+    private _getCategoryUrl;
+    private _resetInventories;
+    private _getCategoryParentsUrl;
+    addCategory: (category: Partial<ICategory>) => Promise<string | boolean | undefined>;
+    updateCategory: (partial: Partial<ICategory>, category: ICategory) => Promise<void>;
+    addAttribute: (attribute: IAttribute) => Promise<boolean | string>;
+    private _attributesListener;
+    private _getAttributes;
+    private _addAttribute;
+    private _saveAllActiveProducts;
+    private _generateAllProductIndexes;
+    private _removeAllPromo;
+    private _resetPriceListPrices;
+    private _deleteAllProducts;
+    private _batchProductsCreate;
+    private _batchProductsSet;
+    _productsListener: (callback: (products: Product[]) => any, options?: IQueryOptions) => string;
+    updateProduct: (partial: Partial<IProduct>, product: IProduct) => Promise<void>;
+    createEmptyProduct: () => Product;
+    addProduct: (product: Partial<IProduct>, options?: {
+        index?: boolean;
+    }) => Promise<void>;
+    private _getProducts;
+    private _getProductsPage;
+    private _getAllProducts;
+    fetchSizeBasedOnCategoryAndAttribute: (category: string, attribute?: string) => IPredefinedBox | IPredefinedBox[] | undefined;
+    constructProduct: (productData: IProduct) => Product;
+    productHasDocument: () => boolean;
+    productHasPanelDescriptions: () => boolean;
+    productHasProductUpsells: () => boolean;
+    productHasProductEquivalents: () => boolean;
+    private _decliHasStock;
+    getDeclinationsPriceRange: (declinations: ICartItem[], inventoryItems: IInventoryItem[]) => IPriceRange;
+    getDeclinationsPriceClassesRange: (customPromoApplies: boolean, declinations: ICartItem[], inventoryItems: IInventoryItem[]) => IPriceRange[];
+    private _getAppliedPrice;
+    private _getMin;
+    private _getMinFromDeclinations;
+    getPriceTypeByDeclinations: (sample: ICartItem[]) => "regular_price" | "promo_price" | "discount_price";
+    getPriceTypeForProduct: (declinations: IIndexedDeclination[]) => 'regular' | 'promo' | 'discount';
+    private _getCartItems;
+    private _getAllIndexedProducts;
+    private _saveAllIndexedCategories;
+    private _fetchIndexedVariations;
+    private _fetchIndexedDecliBySlugAndSku;
+    private _getAllInventoryItems;
+    private _getInventoryPage;
+    private _getAllInventoryItemsByPages;
+    private _getInventoryItemsSnapshot;
+    private _getOneInventoryItem;
+    private _setInventoryItem;
+    private _deleteInventoryItem;
+    private _getAllInventoryItemsFromSameProduct;
+    private _getIsSaving;
+    private _setIsSaving;
+    private _getAllTransfertRequests;
+    private _getTransfertRequestsSnapshot;
+    private _getATransfertRequest;
+    private _discountRulesListener;
+    addDiscountRule: (discountRule: IDiscountRule) => Promise<void>;
+    updateDiscountRule: (partial: Partial<IDiscountRule>, discountRule: IDiscountRule) => Promise<void>;
+    private _getDiscountRules;
+    private _deleteDiscountRules;
+    private _getPurchaseOrders;
+    addPurchaseOrder: (purchaseOrder: IPurchaseOrder) => Promise<void>;
+    createEmptyPurchaseOrder: () => PurchaseOrder;
+    generatePurchaseOrders: (declinationsToAdd: IOrderDeclination[]) => Promise<PurchaseOrder[]>;
+    private _singlePurchaseOrderListener;
+    _purchaseOrdersListener: (callback: (purchaseOrders: PurchaseOrder[]) => any, options?: IQueryOptions) => string;
+    private _getClasses;
+    private _classesListener;
+    addClass: (classObj: Partial<IClass>) => Promise<string | boolean | undefined>;
+    private _getSuppliers;
+    createEmptySupplier: () => Supplier;
+    private _suppliersListener;
+    createEmptyCart: (save?: boolean, cartType?: CartTypeEnum, defaultPickup?: boolean) => Promise<Cart>;
+    createEmptyCartSync: (cartType?: CartTypeEnum) => Cart;
+    private _getCarts;
+    private _cartsListener;
+    private _deleteOrders;
+    getWarehouseAvailability: (cartItems: ICartItem[]) => Promise<{
+        web: number;
+        store: number;
+    }>;
+    private _getAllOrderTypes;
+    private _listenOrder;
+    private _getInvoices;
+    private _invoicesListener;
+    private _getUnknownCartItem;
+    private _importInvoices;
+    private _generateNewPromiseId;
+    private _incrementInvoiceRef;
+    private _incrementGeneralInvoiceRef;
+    private _incrementStoreOrWebInvoiceRef;
+    private _constructNewRefForInvoice;
+    private _getSpaceBillingEmailsToSendInvoice;
+    private _batchInvoicesCreate;
+    private _batchInvoiceDelete;
+    private _getOrders;
+    private _ordersListener;
+    private _customersListener;
+    createEmptyCustomer: () => Customer;
+    private _createCustomerWithId;
+    private _deleteOneCustomer;
+    addCustomer: (customer: ICustomer, oldID?: string, skipEmailCheck?: boolean) => Promise<{
+        saved: boolean;
+        error: {
+            fr: string;
+            en: string;
+        };
+        sameEmail?: undefined;
+    } | {
+        saved: boolean;
+        error: {
+            fr: string;
+            en: string;
+        };
+        sameEmail: boolean;
+    } | {
+        saved: boolean;
+        error?: undefined;
+        sameEmail?: undefined;
+    }>;
+    private _getCustomers;
+    private _batchCustomerAddressesCreate;
+    private _batchCustomerWishlistsCreate;
+    private _batchCustomerAlertCreate;
+    private _batchCustomersCreate;
+    private _fetchIndexedCustomers;
+    private _getCustomerPromisesToPurchase;
+    private _getPossibleActiveBanksForCustomer;
+    private _ajustInventoryWithCart;
+    private _addTag;
+    private _getAllTags;
+    private _deleteAllTags;
+    private _getUser;
+    private _getUserByExternalID;
+    private _disableUser;
+    private _enableUser;
+    private _getUserModel;
+    private _saveUser;
+    private _reinitUserPassword;
+    private _deleteUser;
+    translateToDefault: (dict: ITranslation[]) => string;
+    generateNewCustomerId: () => Promise<string | boolean>;
+    uploadStringToPath: (value: string, path: string, name: string, type: string) => Promise<any>;
+    _shouldSpreadDeclinationsAtIndexing: () => boolean;
+    _shouldIndexUnpaidCarts: () => boolean;
+    _prosprShouldSpreadDeclinationsAtIndexing: () => boolean;
+    _setWebsiteMaintenance: (is_in_maintenance: boolean) => Promise<void>;
+    private _setHideProPrices;
+    private _setFixedPromoBanner;
+    private _getBookings;
+    private _bookingsListener;
+    createNewBooking: (save?: boolean) => Promise<{
+        saved: string | boolean;
+        booking: Booking;
+    } | {
+        saved: boolean;
+        booking: undefined;
+    }>;
+    private _updateG2Calls;
+    publicToken: () => string | undefined;
+    getImportModel: () => import("../../Interfaces/Space").IImportModelLine[];
+    private _getDefaultLocale;
+    private _getDefaultCurrency;
+    private _getLanguages;
+    private _getDefaultWeightUnit;
+    private _getDefaultMeasurmentsUnit;
+    private _getEnabledCurrencies;
+    _getAlgoliaApp: () => any;
+    _getAlgoliaKey: () => any;
+    _getAlgoliaAdmin: () => any;
+    _getProsprSearchApp: () => any;
+    _getStorageServiceName: () => string;
+    _getStorageServiceConfig: () => {
+        readonly [key: string]: any;
+    };
+    private _getUpdateByObjectID;
+    private _getUpdateByType;
+    private _getBankTypes;
+    private _addBankType;
+    private _updateBankType;
+    private _getPromiseBankRules;
+    private _syncCustomerPromiseToPurchaseAssoc;
+    private _getAllWithActivePromises;
+    private _getBanksUsedHistoryForCustomer;
+    private _getAvailableBankAmountsByBankType;
+    private _getPromisesToPurchase;
+    private _getPromiseToPurchaseEmails;
+    private _getPromiseToPurchaseContingency;
+    private _getPromiseToPurchaseSeasons;
+    private _deactivateAllPromisesToPurchase;
+    private _closeSeasonPromisesToPurchase;
+    private _openSeasonPromisesToPurchase;
+    private _endSeasonPromisesToPurchase;
+    private _getEscompteItems;
+    private _getPromiseAssociatedCarts;
+    private _getBanksUsedHistory;
+    private _getAvailableBankAmountForApplicableBanks;
+    private _getAvailableBankAmountsForPromise;
+    private _getSpecificAvailableBankAmount;
+    private _getJobs;
+    private _jobsListener;
+    private _startJob;
+    setInventoryPriority: (type: InventoryPriorityTypeEnum) => Promise<void>;
+    setPrincipalWarehouseInventory: (warehouseId: string) => Promise<{
+        stores_warehouses: {
+            can_sell_online: boolean;
+            id?: string | undefined;
+            personnal_id?: string | undefined;
+            store_num?: string | undefined;
+            type: import("../../Interfaces/Store").StoreTypeEnum;
+            name: string;
+            can_ship: boolean;
+            is_pickup_point?: boolean | undefined;
+            show_on_contact?: boolean | undefined;
+            order?: number | undefined;
+            address: import("../../Interfaces/Address").default;
+            phone: string;
+            store_customer_id?: string | undefined;
+            email?: string | undefined;
+            position?: {
+                readonly lat: number;
+                readonly lng: number;
+            } | undefined;
+            tax_numbers?: {
+                tax_family_id: string;
+                tax_label_fr: string;
+                tax_number: string;
+            }[] | undefined;
+            allow_immediate_pickup?: boolean | undefined;
+            payment_ref_is_mandatory?: boolean | undefined;
+            payment_shortcuts?: {
+                display_text: string;
+                url: string;
+            }[] | undefined;
+        }[];
+    } | undefined>;
+    private _getSliders;
+    private _getAllDocuments;
+    private _saveDocument;
+    attributes: {
+        get: (options?: IQueryOptions) => Promise<Attribute[]>;
+        add: (attribute: IAttribute) => Promise<void>;
+        listener: (callback: (attributes: Attribute[]) => any) => string;
+    };
+    blogArticles: {
+        get: () => Promise<BlogArticle[]>;
+    };
+    blogAuthors: {
+        get: () => Promise<BlogAuthor[]>;
+    };
+    blogCategories: {
+        get: () => Promise<BlogCategory[]>;
+        listener: (callback: (blogCategories: BlogCategory[]) => any) => string;
+    };
+    blogKeywords: {
+        get: () => Promise<BlogKeyword[]>;
+    };
+    catalogues: {
+        get: () => Promise<Catalogue[]>;
+        getOne: (id: string) => Promise<Catalogue | undefined>;
+        checkIfSlugUnique: (slug: string, id: string) => Promise<boolean>;
+        save: (catalogue: ICatalogue) => Promise<string | boolean>;
+        delete: (ids: string[]) => Promise<boolean>;
+    };
+    categories: {
+        get: (options?: IQueryOptions) => Promise<Category[]>;
+        getTree: (categories: Category[], level?: number, parent?: string) => any;
+        listener: (callback: (categories: Category[]) => any, options?: ICategoryQueryOptions) => string;
+        url: (categoryID: string) => Promise<string>;
+        resetInventories: (categoryId: string) => Promise<void>;
+    };
+    brands: {
+        get: (options?: IQueryOptions) => Promise<Brand[]>;
+        listener: (callback: (brands: Brand[]) => any, options?: IBrandQueryOptions) => string;
+    };
+    products: {
+        get: (options?: IQueryOptions) => Promise<Product[]>;
+        getPage: (from: string | undefined, limit: number) => Promise<Product[]>;
+        getAll: () => Promise<Product[]>;
+        listener: (callback: (products: Product[]) => any, options?: IQueryOptions) => string;
+        batch: {
+            create: (products: IProduct[]) => Promise<void>;
+            set: (products: IProduct[]) => Promise<void>;
+        };
+        save: {
+            allActive: () => Promise<void>;
+        };
+        generate: {
+            indexes: () => Promise<IIndexedProduct[] | undefined>;
+        };
+        delete: (options?: IQueryOptions) => Promise<unknown>;
+        removeAllPromo: (infoCallBack: Function) => Promise<boolean>;
+        getMinFromDeclinations: (d: IDeclination) => import("../../Interfaces/Cart").ICartItemPrices;
+        resetPriceListPrices: (infoCallBack: Function) => Promise<boolean>;
+    };
+    indexedProducts: {
+        get: (options?: IQueryOptions, lang?: string, currency?: string) => Promise<IndexedProduct[]>;
+        fetchVariations: ({ app, api, hpp, page, query, filters, indice, f, space, useProspr }: IQueryProps) => Promise<SearchResponse>;
+        getOneIndexedDecli: (parentSlug: string, sku: string, customPriceList?: ICustomPriceItem[]) => Promise<IIndexedDeclination | undefined>;
+    };
+    indexedCategories: {
+        save: (tree: any) => Promise<false | undefined>;
+    };
+    inventoryItems: {
+        get: (options?: IQueryOptions) => Promise<IInventoryItem[]>;
+        getAll: () => Promise<IInventoryItem[]>;
+        snapshot: (callback: (allInventoryItems: IInventoryItem[]) => void) => string;
+        getOne: (sku: string) => Promise<IInventoryItem | undefined>;
+        set: (sku: string, data: Partial<IInventoryItem>) => Promise<boolean>;
+        delete: (sku: string) => Promise<boolean>;
+        setIsSavingInventory: (user_email: string | null) => Promise<void>;
+        getIsSavingInventory: () => Promise<string | null>;
+        getAllFromSameProduct: (product_slug: string) => Promise<false | Inventory[]>;
+    };
+    transferRequests: {
+        get: () => Promise<TransferRequest[]>;
+        snapshot: (callback: (allTransferRequests: TransferRequest[]) => void) => string;
+        getOne: (transfert_request_id: string) => Promise<TransferRequest>;
+    };
+    cartItem: {
+        get: (options?: IQueryOptions, locale?: string, currencies?: string[], noLimit?: boolean) => Promise<IIndexedProduct[]>;
+        getMin: (cartItem: ICartItem, ignoreTierPricing?: boolean) => import("../../Interfaces/Cart").ICartItemPrices;
+        getAppliedPrice: (cartItem: ICartItem) => import("../../Interfaces/Cart").ICartItemPrices;
+    };
+    purchaseOrders: {
+        get: (options?: IQueryOptions) => Promise<PurchaseOrder[]>;
+        singleListener: (callback: (purchaseOrder: PurchaseOrder | null) => any, id: string) => Promise<string>;
+        listener: (callback: (purchaseOrders: PurchaseOrder[]) => any, options?: IQueryOptions) => string;
+    };
+    discountRules: {
+        get: (options?: IQueryOptions) => Promise<Discount[]>;
+        listener: (callback: (discountRule: Discount[]) => any, options?: IQueryOptions) => string;
+        delete: (discountIdsArray: string[]) => Promise<true | never[]>;
+    };
+    addresses: {
+        batch: {
+            create: (data: any) => Promise<void>;
+        };
+    };
+    jobs: {
+        get: (options?: IQueryOptions) => Promise<BGJob[] | undefined>;
+        listener: (callback: (job: BGJob[]) => any, options?: IQueryOptions) => string;
+        start: (jobToStart: IBGJob) => Promise<string | boolean>;
+    };
+    wishlists: {
+        batch: {
+            create: (data: any) => Promise<void>;
+        };
+    };
+    alerts: {
+        batch: {
+            create: (data: any) => Promise<void>;
+        };
+    };
+    customers: {
+        get: (options?: IQueryOptions) => Promise<Customer[]>;
+        listener: (callback: (customer: Customer[]) => any, options?: IQueryOptions) => string;
+        createWithId: (id: string, customer: ICustomer) => Promise<boolean>;
+        deleteOne: (id: string) => Promise<boolean | undefined>;
+        fetchIndexed: ({ app, api, hpp, page, query, filters, indice, f, space, useProspr }: IQueryProps) => Promise<SearchResponse>;
+        getPromisesForCustomer: (customerID: string, onlyActive?: boolean) => Promise<PromiseToPurchase[]>;
+        getApplicableBanksForCustomer: (customerID: string, promisesToCheck?: PromiseToPurchase[]) => Promise<IApplicablePromiseBank[]>;
+        syncCustomerPromiseList: (associations: Record<string, IIndexedCustomerPromiseToPurchase['associated_promise_ids']>) => Promise<boolean>;
+        getAllWithActivePromises: () => Promise<Customer[] | null>;
+        getPABanksHistoryForCustomer: (customerID: string, filterOptions?: {
+            promiseID?: string;
+            bankTypeID?: string;
+            updateType?: BankUpdateTypeEnum;
+            unixDateRange?: {
+                start: number;
+                end: number;
+            };
+        }, searchOptions?: {
+            hpp?: number;
+            page?: number;
+            query?: string;
+        }) => Promise<IIndexedBankUsed[] | undefined>;
+        getAvailablePABankAmounts: (customerID: string, filterToApply?: 'active-and-before' | 'active-and-after' | 'last-emptied-active-and-after') => Promise<{
+            [bankID: string]: IRemainingBankAmount[];
+        } | undefined>;
+        batch: {
+            create: (customers: ICustomer[]) => Promise<void>;
+        };
+    };
+    bookings: {
+        get: (options?: IQueryOptions) => Promise<Booking[]>;
+        listener: (callback: (customer: Booking[]) => any, options?: IQueryOptions) => string;
+    };
+    classes: {
+        listener: (callback: (classes: Class[]) => any) => string;
+        get: (options?: IQueryOptions) => Promise<Class[]>;
+    };
+    suppliers: {
+        listener: (callback: (suppliers: Supplier[]) => any) => string;
+        get: (options?: IQueryOptions) => Promise<Supplier[]>;
+    };
+    invoices: {
+        listener: (callback: (invoices: Invoice[]) => any) => string;
+        get: (options?: IQueryOptions) => Promise<Invoice[]>;
+        import: (fileImport: any) => Promise<any[]>;
+        incrementRef: (cartData: ICart) => Promise<string | undefined>;
+        shouldSendBillingEmailTo: (isDelivery?: boolean) => string[];
+        batch: {
+            create: (invoices: ICart[]) => Promise<void>;
+            delete: (invoices: ICart[] | any[]) => Promise<void>;
+        };
+    };
+    orders: {
+        get: (options?: IQueryOptions) => Promise<Order[]>;
+        listener: (callback: (orders: Order[]) => any) => string;
+    };
+    carts: {
+        get: (options?: IQueryOptions) => Promise<Cart[]>;
+        listener: (callback: (carts: Cart[]) => any, query?: IQueryOptions) => string;
+        delete: (ids: string[]) => Promise<void>;
+    };
+    allOrderTypes: {
+        get: (id?: string) => Promise<any>;
+    };
+    accounting: {
+        external_services: {
+            get: () => Promise<ExternalService[]>;
+        };
+    };
+    taxes: {
+        get: (taxCode: string, version?: string) => Promise<ITax>;
+        getAll: () => Promise<ITax[]>;
+    };
+    consentForms: {
+        getMostRecent: () => Promise<import("../../Interfaces/Consent").default | undefined>;
+    };
+    documents: {
+        products: () => string;
+        queue: () => string;
+        getAll: (specificPath: string) => Promise<IBucketDocument[] | undefined>;
+        save: (file: File, specificPath: string, imgixUrl?: string, imgixKey?: string) => Promise<void>;
+    };
+    preferences: {
+        default: {
+            locale: () => string;
+            currency: () => string;
+        };
+        units: {
+            weight: () => "kilograms" | "pounds";
+            measurments: () => "centimeters" | "inches";
+        };
+        languages: () => ("fr" | "en")[];
+        currencies: () => string[];
+        pickup: {
+            disabled: (value: boolean) => Promise<boolean>;
+        };
+        shipping: {
+            fees: {
+                update: (forProps: string, value: number) => Promise<boolean>;
+            };
+            disabled: (value: boolean) => Promise<boolean>;
+            asProduct: {
+                setAsProduct: (value: boolean) => Promise<boolean>;
+                get: () => boolean;
+            };
+            boxes: {
+                add: () => Promise<boolean>;
+                deleteAt: (bIndex: number) => Promise<boolean>;
+                updateAt: (bIndex: number, value: any, forProps: string) => Promise<boolean>;
+                get: () => IPredefinedBox[];
+            };
+            products: {
+                add: () => Promise<boolean>;
+                deleteAt: (bIndex: number) => Promise<boolean>;
+                updateAt: (bIndex: number, value: any, forProps: string) => Promise<boolean>;
+                get: () => IPredefinedBox[];
+            };
+            units: {
+                add: () => Promise<boolean>;
+                deleteAt: (bIndex: number) => Promise<boolean>;
+                updateAt: (bIndex: number, value: any, forProps: string) => Promise<boolean>;
+                get: () => IDimensionUnit[];
+            };
+            envelops: {
+                add: () => Promise<boolean>;
+                deleteAt: (bIndex: number) => Promise<boolean>;
+                updateAt: (bIndex: number, value: any, forProps: string) => Promise<boolean>;
+                get: () => IPredefinedBox[];
+            };
+            restrict: {
+                updateFree: (newValue: IShippingRangeRestrictions | boolean) => Promise<boolean>;
+                updateFreeValues: (newValues: string[], listType: string) => Promise<boolean | undefined>;
+                getFree: () => boolean | IShippingRangeRestrictions | undefined;
+            };
+            blocked_dates: {
+                get: () => IBlockedDates[] | undefined;
+                getOne: (cartType: string) => IBlockedDates | undefined;
+                update: (newValues: IBlockedDates[]) => Promise<boolean>;
+            };
+        };
+        stores: {
+            get: () => IStore[];
+            add: (store: IStore) => void;
+            update: (store: IStore, index: number) => Promise<IStore[]>;
+            delete: (index: number) => Promise<void>;
+        };
+        products: {
+            get: () => import("../../Interfaces/Space").IProductPreferences;
+        };
+        cms: {
+            setWebsiteMaintenance: (is_in_maintenance: boolean) => Promise<void>;
+            setHideProPrices: (hideProPrices: boolean) => Promise<boolean | undefined>;
+            setFixedPromoBanner: (fixedPromoBannerData: IFixedPromoBanner) => Promise<boolean>;
+        };
+        algolia: {
+            app: () => any;
+            key: () => any;
+            admin: () => any;
+            shouldSpreadDeclinationsAtIndexing: () => boolean;
+        };
+        prosprsearch: {
+            app: () => any;
+            shouldSpreadDeclinationsAtIndexing: () => boolean;
+            shouldIndexUnpaidCarts: () => boolean;
+        };
+        customers: {
+            groups: () => import("../../Interfaces/Space").ICustomerGroup[] | undefined;
+        };
+        storage: {
+            getServiceName: () => string;
+            getServiceConfig: () => {
+                readonly [key: string]: any;
+            };
+        };
+    };
+    options: {
+        get: () => ISpaceOptions;
+        save: (newOptions: ISpaceOptions) => Promise<boolean>;
+    };
+    g2Calls: {
+        update: (optionsToUpdate: Partial<IG2Calls>) => Promise<boolean>;
+    };
+    services: (query: any) => IExternalServices[];
+    inventory: {
+        ajust: (items: ICartItem[], cartState: 'paid' | 'shipped' | 'delivery' | 'delivered' | 'picked' | 'cancelled' | 'modified', cartType: CartTypeEnum, currentStoreId?: string | undefined, onlyWeb?: boolean) => Promise<void>;
+    };
+    tags: {
+        add: (declination: IDeclination, product: IProduct, category_slug: string, inventory: IInventoryItem, currentStoreId: string, maxQte: number, isOtherCategory?: boolean) => Promise<string | boolean | undefined>;
+        get: (options?: IQueryOptions) => Promise<Tag[] | undefined>;
+        delete: () => Promise<boolean[]>;
+    };
+    users: {
+        delete: (userId: string, credentials: any, token: string) => Promise<void>;
+        get: (uid: string) => Promise<IUser>;
+        getByExternalID: (externalID: string) => Promise<IUser | undefined>;
+        disable: (user?: Awaited<ReturnType<typeof User.FetchUser>>) => Promise<User>;
+        enable: (user?: Awaited<ReturnType<typeof User.FetchUser>>) => Promise<User>;
+        model: (user: Awaited<ReturnType<typeof User.FetchUser>>) => User;
+        reinitPassword: (user: Awaited<ReturnType<typeof User.FetchUser>>) => Promise<void>;
+        save: (user: Awaited<ReturnType<typeof User.FetchUser>>) => Promise<IUser>;
+    };
+    updates: {
+        getByID: (objectID: string) => Promise<IUpdate | undefined>;
+        getByType: (type: string) => Promise<IUpdate[] | undefined>;
+    };
+    bankTypes: {
+        get: (id?: string, returnInactive?: boolean) => IBankType[];
+        add: (name: ITranslation[], active: boolean, association_type: BankTypeAssociationEnum, rules: IBankRule[]) => Promise<boolean>;
+        update: (id: string, rules: IBankRule[], name?: ITranslation[], active?: boolean, association_type?: BankTypeAssociationEnum) => Promise<boolean>;
+        getRulesByType: (typeID: string, versionKey?: number) => {
+            version: number;
+            rules: IBankRule[];
+        } | undefined;
+    };
+    promisesToPurchase: {
+        get: (options?: IQueryOptions, onlyMostRecent?: boolean, keepArchived?: boolean) => Promise<PromiseToPurchase[] | undefined>;
+        getEmails: () => string[];
+        getContingency: () => number;
+        getPromiseSeasons: (stateToReturn?: 'ended' | 'closed' | 'open') => {
+            season_year: number;
+            date: Date | undefined;
+            by_user: string | undefined;
+        }[];
+        getEscompteItems: () => Promise<IndexedProduct[]>;
+        generateNewId: (customerId: string, useNextSeason: boolean, idToIncrement?: string) => Promise<string>;
+        getAssociatedCarts: (promiseID: string, options?: IQueryOptions) => Promise<Cart[]>;
+        getBanksUsedHistory: (filterOptions: {
+            customerID?: string;
+            promiseID?: string;
+            bankTypeID?: string;
+            updateType?: BankUpdateTypeEnum;
+            unixDateRange?: {
+                start: number;
+                end: number;
+            };
+        }, searchOptions?: {
+            hpp?: number;
+            page?: number;
+            query?: string;
+        }) => Promise<IIndexedBankUsed[] | undefined>;
+        getAvailableAmountForApplicableBanks: (applicableBanks: IApplicablePromiseBank[], applicableBanksHistory: IIndexedBankUsed[]) => {
+            [bankID: string]: number;
+        };
+        getAvailableBankAmountsForPromise: (promiseID: string, promiseObj?: PromiseToPurchase) => Promise<IRemainingBankAmount[] | undefined>;
+        getSpecificAvailableBankAmount: (promiseID: string, bankID: string, promiseObj?: PromiseToPurchase) => Promise<IRemainingBankAmount | undefined>;
+        closePromiseSeason: (yearToClose: number, userClosingID: string) => Promise<boolean>;
+        openPromiseSeason: (season: number, userOpeningId: string) => Promise<boolean>;
+        endPromiseSeason: (yearToEnd: number, userEndingId: string) => Promise<boolean>;
+        batch: {
+            deactivate: () => Promise<void>;
+        };
+    };
+    sliders: {
+        get: <T>(options?: IQueryOptions) => Promise<Slider<T>[] | undefined>;
+    };
+    data: () => ISpace;
+    getName: () => string;
+    getId: () => string;
+    isMultiPromo: () => boolean;
+}