@unchainedshop/core 4.0.0-rc.9 → 4.0.0

package/src/directors/BasePricingDirector.ts

@@ -70,7 +70,7 @@ export const BasePricingDirector = <
     async rebuildCalculation(this: typeof director, pricingContext, unchainedAPI) {
       const context = await this.buildPricingContext(pricingContext, unchainedAPI);
 
-      let calculation: Calculation[] = [];
+      let calculation: Calculation[] | null = [];
 
       const Adapters = baseDirector.getAdapters({
         adapterFilter: (Adapter) => {
@@ -78,52 +78,55 @@ export const BasePricingDirector = <
         },
       });
 
-      calculation = await Adapters.reduce(async (previousPromise, Adapter) => {
-        const resolvedCalculation = await previousPromise;
-        if (!resolvedCalculation) return null;
-
-        const discounts: Discount<any>[] = await Promise.all(
-          context.discounts.map(async (orderDiscount) => {
-            const order = await unchainedAPI.modules.orders.findOrder({
-              orderId: orderDiscount.orderId,
-            });
-            const DiscountAdapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
-            if (!DiscountAdapter) return null;
-
-            const adapter = await DiscountAdapter.actions({
-              context: { order, orderDiscount, code: orderDiscount.code, ...unchainedAPI },
+      calculation = await Adapters.reduce(
+        async (previousPromise, Adapter) => {
+          const resolvedCalculation = await previousPromise;
+          if (!resolvedCalculation) return null;
+
+          const discounts: (Discount<any> | null)[] = await Promise.all(
+            context.discounts.map(async (orderDiscount) => {
+              const order = await unchainedAPI.modules.orders.findOrder({
+                orderId: orderDiscount.orderId,
+              });
+              const DiscountAdapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+              if (!DiscountAdapter) return null;
+
+              const adapter = await DiscountAdapter.actions({
+                context: { order, orderDiscount, code: orderDiscount.code, ...unchainedAPI },
+              });
+
+              const configuration = adapter.discountForPricingAdapterKey({
+                pricingAdapterKey: Adapter.key,
+                calculationSheet: this.calculationSheet(pricingContext, resolvedCalculation),
+              });
+
+              return {
+                discountId: orderDiscount._id,
+                configuration,
+              };
+            }),
+          );
+
+          try {
+            const adapter = Adapter.actions({
+              context,
+              calculationSheet: this.calculationSheet(pricingContext, resolvedCalculation),
+              discounts: discounts.filter((d) => d?.configuration !== null) as Discount<any>[],
             });
 
-            const configuration = adapter.discountForPricingAdapterKey({
-              pricingAdapterKey: Adapter.key,
-              calculationSheet: this.calculationSheet(pricingContext, calculation),
-            });
+            const nextCalculationResult = await adapter.calculate();
+            if (!nextCalculationResult) return null;
+            calculation = resolvedCalculation.concat(nextCalculationResult);
+            return calculation;
+          } catch (error) {
+            logger.error(error);
+          }
+          return resolvedCalculation;
+        },
+        Promise.resolve([] as Calculation[]),
+      );
 
-            return {
-              discountId: orderDiscount._id,
-              configuration,
-            };
-          }),
-        );
-
-        try {
-          const adapter = Adapter.actions({
-            context,
-            calculationSheet: this.calculationSheet(pricingContext, calculation),
-            discounts: discounts.filter((d) => d?.configuration !== null),
-          });
-
-          const nextCalculationResult = await adapter.calculate();
-          if (!nextCalculationResult) return null;
-          calculation = resolvedCalculation.concat(nextCalculationResult);
-          return calculation;
-        } catch (error) {
-          logger.error(error);
-        }
-        return resolvedCalculation;
-      }, Promise.resolve([]));
-
-      return calculation;
+      return calculation || ([] as Calculation[]);
     },
   };
 

package/src/directors/BasePricingSheet.ts

@@ -93,7 +93,7 @@ export const BasePricingSheet = <Calculation extends PricingCalculation>(
         (oldCalculation, filterKey) =>
           oldCalculation.filter(
             (row: Calculation) =>
-              !!row && (filter[filterKey] === undefined || row[filterKey] === filter[filterKey]),
+              !!row && (filter![filterKey] === undefined || row[filterKey] === filter![filterKey]),
           ),
         this.calculation,
       );

package/src/directors/BaseWorker.ts

@@ -83,7 +83,7 @@ export const BaseWorker: IWorker<WorkerParams> = {
               retries: workConfig.retries || 0,
             };
             if (workConfig.input) {
-              workData.input = await workConfig.input(workData);
+              workData.input = (await workConfig.input(workData)) || {};
               // A work input fn can skip auto scheduling a new record
               // when it explicitly returns a falsish input instead of a dictionary
               if (!workData.input) return null;

package/src/directors/DeliveryAdapter.ts

@@ -19,11 +19,11 @@ export enum DeliveryError {
 }
 
 export interface DeliveryAdapterActions {
-  configurationError: (transactionContext?: any) => DeliveryError;
-  estimatedDeliveryThroughput: (warehousingThroughputTime: number) => Promise<number>;
+  configurationError: (transactionContext?: any) => DeliveryError | null;
+  estimatedDeliveryThroughput: (warehousingThroughputTime: number) => Promise<number | null>;
   isActive: () => boolean;
   isAutoReleaseAllowed: () => boolean;
-  pickUpLocationById: (locationId: string) => Promise<DeliveryLocation>;
+  pickUpLocationById: (locationId: string) => Promise<DeliveryLocation | null>;
   pickUpLocations: () => Promise<DeliveryLocation[]>;
   send: () => Promise<boolean | Work>;
 }

package/src/directors/DeliveryDirector.ts

@@ -6,7 +6,7 @@ import {
   DeliveryError,
 } from './DeliveryAdapter.js';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { OrderDelivery, OrderDeliveryStatus } from '@unchainedshop/core-orders';
+import { Order, OrderDeliveryStatus } from '@unchainedshop/core-orders';
 import { Modules } from '../modules.js';
 import { createLogger } from '@unchainedshop/logger';
 
@@ -14,10 +14,10 @@ const logger = createLogger('unchained:core');
 
 export type IDeliveryDirector = IBaseDirector<IDeliveryAdapter> & {
   sendOrderDelivery: (
-    orderDelivery: OrderDelivery,
+    order: Order,
     transactionContext: Record<string, any>,
     unchainedAPI: { modules: Modules },
-  ) => Promise<OrderDelivery>;
+  ) => Promise<void>;
   actions: (
     deliveryProvider: DeliveryProvider,
     deliveryContext: DeliveryContext,
@@ -33,21 +33,24 @@ export const DeliveryDirector: IDeliveryDirector = {
   actions: async (deliveryProvider, deliveryContext, unchainedAPI) => {
     const Adapter = baseDirector.getAdapter(deliveryProvider.adapterKey);
 
+    if (!Adapter) {
+      throw new Error(`Delivery Plugin ${deliveryProvider.adapterKey} not available`);
+    }
+
     const context = { ...deliveryContext, ...unchainedAPI };
-    const adapter = Adapter?.actions(deliveryProvider.configuration, context);
+    const adapter = Adapter.actions(deliveryProvider.configuration, context);
 
     return {
       configurationError: () => {
-        try {
-          return adapter.configurationError();
-        } catch {
+        if (!adapter) {
           return DeliveryError.ADAPTER_NOT_FOUND;
         }
+        return adapter.configurationError();
       },
 
       estimatedDeliveryThroughput: async (warehousingThroughputTime) => {
         try {
-          const throughput = await adapter.estimatedDeliveryThroughput(warehousingThroughputTime);
+          const throughput = await adapter?.estimatedDeliveryThroughput(warehousingThroughputTime);
           return throughput;
         } catch (error) {
           logger.warn('Delivery Director -> Error while estimating delivery throughput', {
@@ -58,6 +61,7 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       isActive: () => {
+        if (!adapter) return false;
         try {
           return adapter.isActive();
         } catch (error) {
@@ -69,6 +73,7 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       isAutoReleaseAllowed: () => {
+        if (!adapter) return false;
         try {
           return adapter.isAutoReleaseAllowed();
         } catch (error) {
@@ -80,39 +85,47 @@ export const DeliveryDirector: IDeliveryDirector = {
       },
 
       send: async () => {
+        if (!adapter) throw new Error('Delivery adapter not found');
         return adapter.send();
       },
 
       pickUpLocationById: async (locationId) => {
-        return adapter.pickUpLocationById(locationId);
+        if (!adapter) throw new Error('Delivery adapter not found');
+        return adapter?.pickUpLocationById(locationId);
       },
 
       pickUpLocations: async () => {
+        if (!adapter) throw new Error('Delivery adapter not found');
         return adapter.pickUpLocations();
       },
     };
   },
 
-  sendOrderDelivery: async (orderDelivery, transactionContext, unchainedAPI) => {
+  sendOrderDelivery: async (order, transactionContext, unchainedAPI) => {
+    const orderDelivery = await unchainedAPI.modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId!,
+    });
+
     if (
-      unchainedAPI.modules.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN
+      unchainedAPI.modules.orders.deliveries.normalizedStatus(orderDelivery!) !==
+      OrderDeliveryStatus.OPEN
     )
-      return orderDelivery;
+      return;
 
-    const order = await unchainedAPI.modules.orders.findOrder({ orderId: orderDelivery.orderId });
     const deliveryProvider = await unchainedAPI.modules.delivery.findProvider({
-      deliveryProviderId: orderDelivery.deliveryProviderId,
+      deliveryProviderId: orderDelivery!.deliveryProviderId,
     });
-    const address = orderDelivery.context?.address || order || order.billingAddress;
+
+    const address = orderDelivery!.context?.address || order!.billingAddress;
 
     const adapter = await DeliveryDirector.actions(
-      deliveryProvider,
+      deliveryProvider!,
       {
-        order,
-        orderDelivery,
+        order: order!,
+        orderDelivery: orderDelivery!,
         transactionContext: {
           ...(transactionContext || {}),
-          ...(orderDelivery.context || {}),
+          ...(orderDelivery!.context || {}),
           ...(address || {}),
         },
       },
@@ -120,14 +133,11 @@ export const DeliveryDirector: IDeliveryDirector = {
     );
 
     const arbitraryResponseData = await adapter.send();
-
     if (arbitraryResponseData) {
-      return await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery._id, {
+      await unchainedAPI.modules.orders.deliveries.updateStatus(orderDelivery!._id, {
         status: OrderDeliveryStatus.DELIVERED,
         info: JSON.stringify(arbitraryResponseData),
       });
     }
-
-    return orderDelivery;
   },
 };

package/src/directors/DeliveryPricingAdapter.ts

@@ -42,7 +42,7 @@ export interface DeliveryPricingAdapterContext extends BasePricingAdapterContext
   provider: DeliveryProvider;
   providerContext?: any;
   order: Order;
-  orderDelivery: OrderDelivery;
+  orderDelivery?: OrderDelivery;
   user: User;
   discounts: OrderDiscount[];
 }

package/src/directors/DeliveryPricingDirector.ts

@@ -52,18 +52,18 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
       const provider = await modules.delivery.findProvider({
         deliveryProviderId: item.deliveryProviderId,
       });
-      const user = await modules.users.findUserById(order.userId);
+      const user = await modules.users.findUserById(order!.userId);
       const discounts = await modules.orders.discounts.findOrderDiscounts({
         orderId: item.orderId,
       });
 
       return {
         ...unchainedAPI,
-        countryCode: order.countryCode,
+        countryCode: order!.countryCode,
         currencyCode,
-        order,
-        provider,
-        user,
+        order: order!,
+        provider: provider!,
+        user: user!,
         discounts,
         orderDelivery: item,
         providerContext: null,
@@ -78,7 +78,6 @@ export const DeliveryPricingDirector: IDeliveryPricingDirector<any> = {
       provider: context.provider,
       user: context.user,
       discounts: [],
-      orderDelivery: null,
       providerContext: context.providerContext,
     };
   },

package/src/directors/DeliveryPricingSheet.ts

@@ -61,7 +61,8 @@ export const DeliveryPricingSheet = (
           category: DeliveryPricingRowCategory.Discount,
           discountId: explicitDiscountId,
         })
-        .map(({ discountId }) => discountId);
+        .map(({ discountId }) => discountId)
+        .filter(Boolean) as string[];
 
       return [...new Set(discountIds)]
         .map((discountId) => {
@@ -78,7 +79,7 @@ export const DeliveryPricingSheet = (
             currencyCode,
           };
         })
-        .filter(Boolean);
+        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
     },
   };
 

package/src/directors/EnrollmentAdapter.ts

@@ -1,6 +1,7 @@
 import { BaseAdapter, IBaseAdapter } from '@unchainedshop/utils';
 import {
   Enrollment,
+  EnrollmentOrderPositionTemplate,
   EnrollmentPeriod,
   EnrollmentPlan,
   addToDate,
@@ -10,13 +11,17 @@ import type { OrderPosition } from '@unchainedshop/core-orders';
 
 export interface EnrollmentContext {
   enrollment: Enrollment;
+  product: Product;
 }
 
 export interface EnrollmentAdapterActions {
-  configurationForOrder: (params: { period: EnrollmentPeriod; products: Product[] }) => Promise<any>;
+  configurationForOrder: (params: { period: EnrollmentPeriod }) => Promise<{
+    orderContext?: Record<string, any>;
+    orderPositionTemplates: EnrollmentOrderPositionTemplate[];
+  } | null>;
   isOverdue: () => Promise<boolean>;
   isValidForActivation: () => Promise<boolean>;
-  nextPeriod: () => Promise<EnrollmentPeriod>;
+  nextPeriod: () => Promise<EnrollmentPeriod | null>;
 }
 
 export type IEnrollmentAdapter = IBaseAdapter & {
@@ -71,10 +76,8 @@ export const EnrollmentAdapter: Omit<IEnrollmentAdapter, 'key' | 'label' | 'vers
       isValidForActivation: async () => false,
 
       nextPeriod: async () => {
-        const { enrollment } = context;
-        const product = await (context as any).modules.products.findProduct({
-          productId: enrollment.productId,
-        });
+        const { enrollment, product } = context;
+
         const plan = product?.plan;
         const referenceDate = new Date();
         if (!plan) return null;

package/src/directors/EnrollmentDirector.ts

@@ -10,9 +10,15 @@ const logger = createLogger('unchained:core');
 export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
   transformOrderItemToEnrollment: (
     item: { orderPosition: OrderPosition; product: Product },
-    doc: Omit<Enrollment, 'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log'>,
+    doc: Omit<
+      Enrollment,
+      'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log' | '_id' | 'created'
+    >,
     unchainedAPI,
-  ) => Promise<Omit<Enrollment, 'status' | 'periods' | 'log'>>;
+  ) => Promise<
+    Omit<Enrollment, 'status' | 'periods' | 'log' | '_id' | 'created'> &
+      Pick<Partial<Enrollment>, '_id' | 'created'>
+  >;
 
   actions: (enrollmentContext: EnrollmentContext, unchainedAPI) => Promise<EnrollmentAdapterActions>;
 };
@@ -53,12 +59,7 @@ export const EnrollmentDirector: IEnrollmentDirector = {
   actions: async (enrollmentContext, unchainedAPI) => {
     const context = { ...enrollmentContext, ...unchainedAPI };
 
-    // Resolve adapter
-    const product = await context.modules.products.findProduct({
-      productId: context.enrollment.productId,
-    });
-
-    const Adapter = findAppropriateAdapters(product?.plan)?.[0];
+    const Adapter = findAppropriateAdapters(enrollmentContext.product.plan)?.[0];
 
     if (!Adapter) {
       throw new Error('No suitable enrollment plugin available for this plan configuration');

package/src/directors/FilterAdapter.ts

@@ -21,7 +21,7 @@ export interface FilterAdapterActions {
 
   searchAssortments: (
     params: {
-      assortmentIds: string[];
+      assortmentIds?: string[];
     },
     options: {
       filterSelector: mongodb.Filter<Filter>;
@@ -29,7 +29,7 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<string[]>;
+  ) => Promise<string[] | undefined>;
 
   searchProducts: (
     params: {
@@ -41,7 +41,7 @@ export interface FilterAdapterActions {
       sortStage: mongodb.FindOptions['sort'];
       locale: Intl.Locale;
     },
-  ) => Promise<string[]>;
+  ) => Promise<string[] | undefined>;
 
   transformFilterSelector: (
     query: mongodb.Filter<Filter>,

package/src/directors/FilterDirector.ts

@@ -12,7 +12,7 @@ import {
 import { Product } from '@unchainedshop/core-products';
 import { Modules } from '../modules.js';
 
-export const parseQueryArray = (query: SearchFilterQuery): Record<string, string[]> =>
+export const parseQueryArray = (query?: SearchFilterQuery): Record<string, string[]> =>
   (query || []).reduce(
     (accumulator, { key, value }) => ({
       ...accumulator,
@@ -80,7 +80,7 @@ export const FilterDirector: IFilterDirector = {
       initialValue: V,
     ) => {
       if (adapters.length === 0) {
-        return null;
+        return initialValue;
       }
       return adapters.reduce(async (lastSearchPromise, adapter, index) => {
         return reducer(lastSearchPromise, adapter, index);
@@ -89,22 +89,21 @@ export const FilterDirector: IFilterDirector = {
 
     return {
       aggregateProductIds: (params) => {
-        const reducedProductIds = adapters.reduce(
+        return adapters.reduce(
           (productIds, adapter) => adapter.aggregateProductIds({ productIds }),
           params.productIds,
         );
-        return reducedProductIds;
       },
 
       searchAssortments: async (params, options) => {
-        return reduceAdapters<string[]>(async (lastSearchPromise, adapter) => {
+        return reduceAdapters<string[] | undefined>(async (lastSearchPromise, adapter) => {
           const assortmentIds = await lastSearchPromise;
           return adapter.searchAssortments({ assortmentIds }, options);
         }, params.assortmentIds);
       },
 
       searchProducts: async (params, options) => {
-        return reduceAdapters<string[]>(async (lastSearchPromise, adapter) => {
+        return reduceAdapters<string[] | undefined>(async (lastSearchPromise, adapter) => {
           const productIds = await lastSearchPromise;
           return adapter.searchProducts({ productIds }, options);
         }, params.productIds);
@@ -113,19 +112,19 @@ export const FilterDirector: IFilterDirector = {
       transformProductSelector: async (defaultSelector, options) => {
         return reduceAdapters<mongodb.Filter<Product>>(async (lastSelector, adapter) => {
           return adapter.transformProductSelector(await lastSelector, options);
-        }, defaultSelector || null);
+        }, defaultSelector);
       },
 
       transformSortStage: async (defaultStage, options) => {
         return reduceAdapters<mongodb.FindOptions<Product>['sort']>(async (lastSortStage, adapter) => {
           return adapter.transformSortStage(await lastSortStage, options);
-        }, defaultStage || null);
+        }, defaultStage);
       },
 
       transformFilterSelector: async (defaultSelector) => {
         return reduceAdapters<mongodb.Filter<Filter>>(async (lastSelector, adapter) => {
           return adapter.transformFilterSelector(await lastSelector);
-        }, defaultSelector || null);
+        }, defaultSelector);
       },
     };
   },
@@ -161,7 +160,7 @@ export const FilterDirector: IFilterDirector = {
       filter.type === FilterType.SWITCH
         ? {
             true: await this.findProductIds(filter, { value: true }, unchainedAPI),
-            false: await this.findProductIds(filter, { value: false }, unchainedAPI),
+            false: await this.findProductIds(filter, { value: { $in: [null, false] } }, unchainedAPI),
           }
         : await (filter.options || []).reduce(async (accumulatorPromise, option) => {
             const accumulator = await accumulatorPromise;
@@ -188,7 +187,7 @@ export const FilterDirector: IFilterDirector = {
       values,
       Object.keys(keyToProductIdMap),
     );
-    const result = [];
+    const result: string[] = [];
     for (const key of filteredKeys) {
       const additionalValues = key === undefined ? allProductIds : keyToProductIdMap[key];
       if (additionalValues) {
@@ -245,7 +244,7 @@ export const FilterDirector: IFilterDirector = {
   async filterFacets(filter, params, unchainedAPI) {
     const { allProductIds, searchQuery, forceLiveCollection, otherFilters } = params;
 
-    const filterQueryParsed = parseQueryArray(searchQuery?.filterQuery);
+    const filterQueryParsed = parseQueryArray(searchQuery.filterQuery);
 
     // The examinedProductIdSet is a set of product id's that:
     // - Fit this filter generally

package/src/directors/MessagingDirector.ts

@@ -21,7 +21,7 @@ export interface EmailTemplateType {
 }
 
 export interface SMSTemplateType {
-  type: 'SMS';
+  type: 'TWILIO' | 'BULKGATE' | 'BUDGETSMS';
   input: {
     from: string;
     to: string;

package/src/directors/OrderDiscountAdapter.ts

@@ -4,7 +4,7 @@ import {
   OrderDiscountConfiguration,
 } from '../directors/index.js';
 
-export const OrderDiscountAdapter: Omit<
+export const OrderDiscountAdapter = BaseDiscountAdapter as Omit<
   IDiscountAdapter<OrderDiscountConfiguration>,
   'key' | 'label' | 'version'
-> = BaseDiscountAdapter;
+>;

package/src/directors/OrderPricingAdapter.ts

@@ -20,9 +20,9 @@ export interface OrderPricingAdapterContext extends BasePricingAdapterContext {
   currencyCode?: string;
   discounts: OrderDiscount[];
   order: Order;
-  orderDelivery: OrderDelivery;
   orderPositions: OrderPosition[];
-  orderPayment: OrderPayment;
+  orderDelivery: OrderDelivery | null;
+  orderPayment: OrderPayment | null;
   user: User;
 }
 

package/src/directors/OrderPricingDirector.ts

@@ -13,9 +13,9 @@ import { Order, OrderDelivery, OrderPayment, OrderPosition } from '@unchainedsho
 export interface OrderPricingContext {
   currencyCode: string;
   order: Order;
-  orderDelivery: OrderDelivery;
+  orderDelivery: OrderDelivery | null;
   orderPositions: OrderPosition[];
-  orderPayment: OrderPayment;
+  orderPayment: OrderPayment | null;
 }
 
 export type OrderPricingDiscount = PricingDiscount & {
@@ -61,7 +61,7 @@ export const OrderPricingDirector: IOrderPricingDirector<any> = {
       orderDelivery: context.orderDelivery,
       orderPayment: context.orderPayment,
       orderPositions: context.orderPositions,
-      user,
+      user: user!,
     };
   },
 

package/src/directors/OrderPricingSheet.ts

@@ -122,7 +122,8 @@ export const OrderPricingSheet = (
           category: OrderPricingRowCategory.Discounts,
           discountId: explicitDiscountId,
         })
-        .map(({ discountId }) => discountId);
+        .map(({ discountId }) => discountId)
+        .filter(Boolean) as string[];
 
       return [...new Set(discountIds)]
         .map((discountId) => {
@@ -139,7 +140,7 @@ export const OrderPricingSheet = (
             currencyCode: basePricingSheet.currencyCode,
           };
         })
-        .filter(Boolean);
+        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
     },
   };
 

package/src/directors/PaymentAdapter.ts

@@ -23,11 +23,11 @@ export type PaymentChargeActionResult = ChargeResult & {
 };
 export interface IPaymentActions {
   charge: (transactionContext?: any) => Promise<PaymentChargeActionResult | false>;
-  configurationError: (transactionContext?: any) => PaymentError;
+  configurationError: (transactionContext?: any) => PaymentError | null;
   isActive: (transactionContext?: any) => boolean;
   isPayLaterAllowed: (transactionContext?: any) => boolean;
   register: (transactionContext?: any) => Promise<any>;
-  sign: (transactionContext?: any) => Promise<string>;
+  sign: (transactionContext?: any) => Promise<string | null>;
   validate: (token?: any) => Promise<boolean>;
   cancel: (transactionContext?: any) => Promise<boolean>;
   confirm: (transactionContext?: any) => Promise<boolean>;