@shopfront/bridge 1.8.0 → 1.11.0

package/lib/ApplicationEvents.d.ts

@@ -15,6 +15,8 @@ import { RequestCustomerListOptions, SellScreenCustomerListOption } from "./Even
 import { SaleKey } from "./Actions/SaleKey";
 import { RequestSaleKeys } from "./Events/RequestSaleKeys";
 import { CompletedSale, SaleComplete } from "./Events/SaleComplete";
+import { UIPipeline } from "./Events/UIPipeline";
+import { PaymentMethodsEnabled } from "./Events/PaymentMethodsEnabled";
 export declare enum ToShopfront {
     READY = "READY",
     SERIALIZED = "SERIALIZED",
@@ -33,11 +35,14 @@ export declare enum ToShopfront {
     RESPONSE_CUSTOMER_LIST_OPTIONS = "RESPONSE_CUSTOMER_LIST_OPTIONS",
     RESPONSE_SALE_KEYS = "RESPONSE_SALE_KEYS",
     PRINT_RECEIPT = "PRINT_RECEIPT",
+    REDIRECT = "REDIRECT",
+    GET_OPTION = "GET_OPTION",
+    RESPONSE_UI_PIPELINE = "RESPONSE_UI_PIPELINE",
     SELL_SCREEN_OPTION_CHANGE = "SELL_SCREEN_OPTION_CHANGE",
     INTERNAL_PAGE_MESSAGE = "INTERNAL_PAGE_MESSAGE",
-    TABLE_UPDATE = "TABLE_UPDATE"
-}
-export declare enum WithinApplication {
+    TABLE_UPDATE = "TABLE_UPDATE",
+    PIPELINE_TRIGGER = "PIPELINE_TRIGGER",
+    SELL_SCREEN_PROMOTION_APPLICABLE = "SELL_SCREEN_PROMOTION_APPLICABLE"
 }
 export interface FromShopfrontReturns {
     READY: void;
@@ -78,11 +83,13 @@ export interface FromShopfrontReturns {
     REQUEST_CUSTOMER_LIST_OPTIONS: Array<SellScreenCustomerListOption>;
     REQUEST_SALE_KEYS: Array<SaleKey>;
     SALE_COMPLETE: void;
+    UI_PIPELINE: Array<UIPipelineResponse>;
+    PAYMENT_METHODS_ENABLED: Array<SellScreenPaymentMethod>;
 }
 export interface InternalPageMessageEvent {
     method: "REQUEST_SETTINGS" | "REQUEST_SELL_SCREEN_OPTIONS" | "EXTERNAL_APPLICATION";
     url: string;
-    message: any;
+    message: unknown;
     reference: InternalMessageSource;
 }
 export interface RegisterChangedEvent {
@@ -96,6 +103,30 @@ export interface FormatIntegratedProductEvent {
 export interface SaleCompletedEvent {
     sale: CompletedSale;
 }
+export declare type UIPipelineResponse = {
+    name: string;
+    content: string;
+};
+export interface UIPipelineBaseContext {
+    location: string;
+}
+export interface UIPipelineContext extends UIPipelineBaseContext {
+    trigger?: () => void;
+}
+export interface SellScreenPaymentMethod {
+    uuid: string;
+    name: string;
+    type: "global" | "cash" | "eftpos" | "giftcard" | "voucher" | "cheque" | "pc-eftpos" | "linkly-vaa" | "direct-deposit" | "tyro" | "custom";
+    default_pay_exact: boolean;
+    background_colour?: string;
+    text_colour?: string;
+}
+export interface PaymentMethodEnabledContext {
+    register: string;
+    customer: false | {
+        uuid: string;
+    };
+}
 export interface FromShopfrontCallbacks {
     READY: (event: RegisterChangedEvent) => MaybePromise<FromShopfrontReturns["READY"]>;
     REQUEST_SETTINGS: () => MaybePromise<FromShopfrontReturns["REQUEST_SETTINGS"]>;
@@ -109,6 +140,8 @@ export interface FromShopfrontCallbacks {
     REQUEST_CUSTOMER_LIST_OPTIONS: () => MaybePromise<FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"]>;
     REQUEST_SALE_KEYS: () => MaybePromise<FromShopfrontReturns["REQUEST_SALE_KEYS"]>;
     SALE_COMPLETE: (event: SaleCompletedEvent) => MaybePromise<FromShopfrontReturns["SALE_COMPLETE"]>;
+    UI_PIPELINE: (event: Array<UIPipelineResponse>, context: UIPipelineContext) => MaybePromise<FromShopfrontReturns["UI_PIPELINE"]>;
+    PAYMENT_METHODS_ENABLED: (event: Array<SellScreenPaymentMethod>, context: PaymentMethodEnabledContext) => MaybePromise<FromShopfrontReturns["PAYMENT_METHODS_ENABLED"]>;
 }
 export interface FromShopfront {
     READY: Ready;
@@ -116,13 +149,15 @@ export interface FromShopfront {
     REQUEST_BUTTONS: RequestButtons;
     REQUEST_TABLE_COLUMNS: RequestTableColumns;
     REQUEST_SELL_SCREEN_OPTIONS: RequestSellScreenOptions;
+    CALLBACK: Callback;
     INTERNAL_PAGE_MESSAGE: InternalPageMessage;
     REGISTER_CHANGED: RegisterChanged;
-    CALLBACK: Callback;
     FORMAT_INTEGRATED_PRODUCT: FormatIntegratedProduct;
     REQUEST_CUSTOMER_LIST_OPTIONS: RequestCustomerListOptions;
-    REQUEST_SALE_KEYS: RequestSaleKeys;
     SALE_COMPLETE: SaleComplete;
+    REQUEST_SALE_KEYS: RequestSaleKeys;
+    UI_PIPELINE: UIPipeline;
+    PAYMENT_METHODS_ENABLED: PaymentMethodsEnabled;
 }
 export declare const directShopfrontEvents: readonly ["SALE_ADD_PRODUCT", "SALE_REMOVE_PRODUCT", "SALE_UPDATE_PRODUCTS", "SALE_CHANGE_QUANTITY", "SALE_ADD_CUSTOMER", "SALE_REMOVE_CUSTOMER", "SALE_CLEAR"];
 export declare type DirectShopfrontEvent = typeof directShopfrontEvents[number];
@@ -132,4 +167,5 @@ export interface FromShopfrontInternal {
     RESPONSE_CURRENT_SALE: "RESPONSE_CURRENT_SALE";
     RESPONSE_DATABASE_REQUEST: "RESPONSE_DATABASE_REQUEST";
     RESPONSE_LOCATION: "RESPONSE_LOCATION";
+    RESPONSE_OPTION: "RESPONSE_OPTION";
 }

package/lib/ApplicationEvents.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.directShopfrontEvents = exports.WithinApplication = exports.ToShopfront = void 0;
+exports.directShopfrontEvents = exports.ToShopfront = void 0;
 var ToShopfront;
 (function (ToShopfront) {
     ToShopfront["READY"] = "READY";
@@ -20,14 +20,16 @@ var ToShopfront;
     ToShopfront["RESPONSE_CUSTOMER_LIST_OPTIONS"] = "RESPONSE_CUSTOMER_LIST_OPTIONS";
     ToShopfront["RESPONSE_SALE_KEYS"] = "RESPONSE_SALE_KEYS";
     ToShopfront["PRINT_RECEIPT"] = "PRINT_RECEIPT";
+    ToShopfront["REDIRECT"] = "REDIRECT";
+    ToShopfront["GET_OPTION"] = "GET_OPTION";
+    ToShopfront["RESPONSE_UI_PIPELINE"] = "RESPONSE_UI_PIPELINE";
     // Emitable Events
     ToShopfront["SELL_SCREEN_OPTION_CHANGE"] = "SELL_SCREEN_OPTION_CHANGE";
     ToShopfront["INTERNAL_PAGE_MESSAGE"] = "INTERNAL_PAGE_MESSAGE";
     ToShopfront["TABLE_UPDATE"] = "TABLE_UPDATE";
+    ToShopfront["PIPELINE_TRIGGER"] = "PIPELINE_TRIGGER";
+    ToShopfront["SELL_SCREEN_PROMOTION_APPLICABLE"] = "SELL_SCREEN_PROMOTION_APPLICABLE";
 })(ToShopfront = exports.ToShopfront || (exports.ToShopfront = {}));
-var WithinApplication;
-(function (WithinApplication) {
-})(WithinApplication = exports.WithinApplication || (exports.WithinApplication = {}));
 exports.directShopfrontEvents = [
     "SALE_ADD_PRODUCT",
     "SALE_REMOVE_PRODUCT",

package/lib/Bridge.d.ts

@@ -5,7 +5,7 @@ interface ApplicationOptions {
     vendor: string;
 }
 interface ApplicationEventListener {
-    (event: keyof ApplicationEvents.FromShopfront | keyof ApplicationEvents.FromShopfrontInternal, data: {}, id: string): void;
+    (event: keyof ApplicationEvents.FromShopfront | keyof ApplicationEvents.FromShopfrontInternal, data: Record<string, unknown>, id: string): void;
 }
 export declare class Bridge {
     static createApplication(options: ApplicationOptions): Application;

package/lib/Bridge.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -143,7 +147,7 @@ class Bridge {
         }
     }
     removeEventListener(listener) {
-        let index = this.listeners.indexOf(listener);
+        const index = this.listeners.indexOf(listener);
         if (index === -1) {
             return;
         }

package/lib/Common/EventEmitter.d.ts

@@ -1,7 +1,8 @@
+import { MaybePromise } from "../Utilities/MiscTypes";
 export declare class EventEmitter {
     protected supportedEvents: Array<string>;
     private listeners;
-    addEventListener(event: string, callback: Function): void;
-    removeEventListener(event: string, callback: Function): void;
-    protected emit(event: string, ...args: any[]): Promise<Array<any>>;
+    addEventListener(event: string, callback: (...args: Array<unknown>) => MaybePromise<unknown>): void;
+    removeEventListener(event: string, callback: (...args: Array<unknown>) => MaybePromise<unknown>): void;
+    protected emit(event: string, ...args: Array<unknown>): Promise<Array<unknown>>;
 }

package/lib/Common/Serializable.d.ts

@@ -1,5 +1,5 @@
 export interface Serialized<T> {
-    properties: Array<any>;
+    properties: Array<unknown>;
     events: {
         [event: string]: Array<string>;
     };

package/lib/EmitableEvents/SellScreenPromotionApplicable.d.ts

@@ -0,0 +1,13 @@
+import { BaseEmitableEvent } from "./BaseEmitableEvent";
+export interface PromotionApplicableData {
+    enable: boolean;
+    key: string;
+}
+export declare class SellScreenPromotionApplicable extends BaseEmitableEvent<PromotionApplicableData> {
+    /**
+     * Enable or disable a set of already created "applicable" promotions
+     * @param key {string} The key to enable or disable, this supports wildcards using an asterisk
+     * @param enable {boolean} Whether the key should be enabled or disabled
+     */
+    constructor(key: string, enable: boolean);
+}

package/lib/EmitableEvents/SellScreenPromotionApplicable.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SellScreenPromotionApplicable = void 0;
+const BaseEmitableEvent_1 = require("./BaseEmitableEvent");
+const ApplicationEvents_1 = require("../ApplicationEvents");
+class SellScreenPromotionApplicable extends BaseEmitableEvent_1.BaseEmitableEvent {
+    /**
+     * Enable or disable a set of already created "applicable" promotions
+     * @param key {string} The key to enable or disable, this supports wildcards using an asterisk
+     * @param enable {boolean} Whether the key should be enabled or disabled
+     */
+    constructor(key, enable) {
+        super(ApplicationEvents_1.ToShopfront.SELL_SCREEN_PROMOTION_APPLICABLE, {
+            key,
+            enable,
+        });
+    }
+}
+exports.SellScreenPromotionApplicable = SellScreenPromotionApplicable;

package/lib/Events/BaseEvent.d.ts

@@ -1,5 +1,6 @@
-export declare abstract class BaseEvent {
-    protected callback: Function;
-    protected constructor(callback: Function);
-    abstract emit(data: object): Promise<any>;
+import { Bridge } from "../Bridge";
+export declare abstract class BaseEvent<TData = any, TCallbackReturn = void, TEmitReturn = any, TCallbackData = TData, TCallbackContext = undefined> {
+    protected callback: (data: TCallbackData, context: TCallbackContext) => TCallbackReturn;
+    protected constructor(callback: (data: TCallbackData, context: TCallbackContext) => TCallbackReturn);
+    abstract emit(data: TData, bridge?: Bridge): Promise<TEmitReturn>;
 }

package/lib/Events/BaseEvent.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEvent = void 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 class BaseEvent {
     constructor(callback) {
         this.callback = callback;

package/lib/Events/Callback.d.ts

@@ -2,5 +2,5 @@ import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEven
 import { BaseEvent } from "./BaseEvent";
 export declare class Callback extends BaseEvent {
     constructor(callback: FromShopfrontCallbacks["CALLBACK"]);
-    emit(data: {}): Promise<FromShopfrontReturns["CALLBACK"]>;
+    emit(): Promise<FromShopfrontReturns["CALLBACK"]>;
 }

package/lib/Events/Callback.js

@@ -6,8 +6,8 @@ class Callback extends BaseEvent_1.BaseEvent {
     constructor(callback) {
         super(callback);
     }
-    async emit(data) {
-        return this.callback();
+    async emit() {
+        return this.callback(undefined, undefined);
     }
 }
 exports.Callback = Callback;

package/lib/Events/FormatIntegratedProduct.d.ts

@@ -1,6 +1,7 @@
 import { BaseEvent } from "./BaseEvent";
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { Bridge } from "../Bridge";
+import { MaybePromise } from "../Utilities/MiscTypes";
 export declare type FormattedSaleProductType = "Normal" | "Product" | "GiftCard" | "Voucher" | "Basket" | "Package" | "Component" | "Integrated";
 export interface SaleGiftCard {
     code: string;
@@ -60,13 +61,23 @@ export interface FormattedSaleProduct {
     requestPrice?: boolean;
     lockQuantity: boolean;
     metaData: {
-        [key: string]: any;
+        [key: string]: unknown;
     };
 }
-export declare class FormatIntegratedProduct extends BaseEvent {
+export declare class FormatIntegratedProduct extends BaseEvent<{
+    data: {
+        product: FormattedSaleProduct;
+    };
+    context: Record<string, never>;
+}, MaybePromise<FromShopfrontReturns["FORMAT_INTEGRATED_PRODUCT"]>, FromShopfrontReturns["FORMAT_INTEGRATED_PRODUCT"], {
+    product: FormattedSaleProduct;
+}, Record<string, never>> {
     constructor(callback: FromShopfrontCallbacks["FORMAT_INTEGRATED_PRODUCT"]);
     emit(data: {
-        product: FormattedSaleProduct;
+        data: {
+            product: FormattedSaleProduct;
+        };
+        context: Record<string, never>;
     }): Promise<FromShopfrontReturns["FORMAT_INTEGRATED_PRODUCT"]>;
     static respond(bridge: Bridge, data: Array<FromShopfrontReturns["FORMAT_INTEGRATED_PRODUCT"]>, id: string): Promise<void>;
 }

package/lib/Events/FormatIntegratedProduct.js

@@ -8,7 +8,7 @@ class FormatIntegratedProduct extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        const result = await Promise.resolve(this.callback(data));
+        const result = await this.callback(data.data, data.context);
         if (typeof result !== "object" || result === null) {
             throw new TypeError("Callback must return an object");
         }

package/lib/Events/InternalPageMessage.d.ts

@@ -1,14 +1,10 @@
 import { BaseEvent } from "./BaseEvent";
-import { FromShopfront, FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
+import { FromShopfront, FromShopfrontCallbacks, FromShopfrontReturns, InternalPageMessageEvent } from "../ApplicationEvents";
 import { InternalMessageSource } from "../APIs/InternalMessages/InternalMessageSource";
 import { Application } from "../Application";
-export declare class InternalPageMessage extends BaseEvent {
+export declare class InternalPageMessage extends BaseEvent<InternalPageMessageEvent> {
     protected application: Application;
     constructor(callback: FromShopfrontCallbacks["INTERNAL_PAGE_MESSAGE"], application: Application);
-    protected createReference(method: keyof FromShopfront, url: string): InternalMessageSource;
-    emit(data: {
-        method: keyof FromShopfront;
-        url: string;
-        message: any;
-    }): Promise<FromShopfrontReturns["INTERNAL_PAGE_MESSAGE"]>;
+    protected createReference(method: keyof FromShopfront | "EXTERNAL_APPLICATION", url: string): InternalMessageSource;
+    emit(data: InternalPageMessageEvent): Promise<FromShopfrontReturns["INTERNAL_PAGE_MESSAGE"]>;
 }

package/lib/Events/InternalPageMessage.js

@@ -17,7 +17,7 @@ class InternalPageMessage extends BaseEvent_1.BaseEvent {
             url: data.url,
             message: data.message,
             reference: this.createReference(data.method, data.url)
-        });
+        }, undefined);
     }
 }
 exports.InternalPageMessage = InternalPageMessage;

package/lib/Events/PaymentMethodsEnabled.d.ts

@@ -0,0 +1,15 @@
+import { BaseEvent } from "./BaseEvent";
+import { FromShopfrontCallbacks, FromShopfrontReturns, PaymentMethodEnabledContext, SellScreenPaymentMethod } from "../ApplicationEvents";
+import { Bridge } from "../Bridge";
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class PaymentMethodsEnabled extends BaseEvent<{
+    data: Array<SellScreenPaymentMethod>;
+    context: PaymentMethodEnabledContext;
+}, MaybePromise<FromShopfrontReturns["PAYMENT_METHODS_ENABLED"]>, FromShopfrontReturns["PAYMENT_METHODS_ENABLED"], Array<SellScreenPaymentMethod>, PaymentMethodEnabledContext> {
+    constructor(callback: FromShopfrontCallbacks["PAYMENT_METHODS_ENABLED"]);
+    emit(data: {
+        data: Array<SellScreenPaymentMethod>;
+        context: PaymentMethodEnabledContext;
+    }): Promise<FromShopfrontReturns["PAYMENT_METHODS_ENABLED"]>;
+    static respond(bridge: Bridge, data: FromShopfrontReturns["PAYMENT_METHODS_ENABLED"], id: string): Promise<void>;
+}

package/lib/Events/PaymentMethodsEnabled.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMethodsEnabled = void 0;
+const BaseEvent_1 = require("./BaseEvent");
+const ApplicationEvents_1 = require("../ApplicationEvents");
+class PaymentMethodsEnabled extends BaseEvent_1.BaseEvent {
+    constructor(callback) {
+        super(callback);
+    }
+    async emit(data) {
+        const result = await this.callback(data.data, data.context);
+        if (typeof result !== "object" || result === null) {
+            throw new TypeError("Callback must return an object");
+        }
+        return result;
+    }
+    static async respond(bridge, data, id) {
+        bridge.sendMessage(ApplicationEvents_1.ToShopfront.RESPONSE_UI_PIPELINE, data, id);
+    }
+}
+exports.PaymentMethodsEnabled = PaymentMethodsEnabled;

package/lib/Events/Ready.d.ts

@@ -1,6 +1,6 @@
-import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
+import { FromShopfrontCallbacks, FromShopfrontReturns, RegisterChangedEvent } from "../ApplicationEvents";
 import { BaseEvent } from "./BaseEvent";
-export declare class Ready extends BaseEvent {
+export declare class Ready extends BaseEvent<RegisterChangedEvent> {
     constructor(callback: FromShopfrontCallbacks["READY"]);
     emit(data: {
         outlet: string | null;

package/lib/Events/Ready.js

@@ -11,7 +11,7 @@ class Ready extends BaseEvent_1.BaseEvent {
             outlet: data.outlet,
             register: data.register,
             user: data.user,
-        });
+        }, undefined);
     }
 }
 exports.Ready = Ready;

package/lib/Events/RegisterChanged.js

@@ -7,7 +7,7 @@ class RegisterChanged extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        this.callback(data);
+        this.callback(data, undefined);
     }
 }
 exports.RegisterChanged = RegisterChanged;

package/lib/Events/RequestButtons.d.ts

@@ -1,12 +1,17 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { Bridge, Button } from "..";
 import { BaseEvent } from "./BaseEvent";
-export declare class RequestButtons extends BaseEvent {
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class RequestButtons extends BaseEvent<{
+    location: string;
+    id: string;
+    context: unknown;
+}, MaybePromise<FromShopfrontReturns["REQUEST_BUTTONS"]>, MaybePromise<FromShopfrontReturns["REQUEST_BUTTONS"]>, string, unknown> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_BUTTONS"]);
     emit(data: {
         location: string;
         id: string;
-        context: any;
+        context: unknown;
     }): Promise<FromShopfrontReturns["REQUEST_BUTTONS"]>;
     static respond(bridge: Bridge, buttons: Array<Button>, id: string): Promise<void>;
 }

package/lib/Events/RequestButtons.js

@@ -9,7 +9,7 @@ class RequestButtons extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        let result = await Promise.resolve(this.callback(data.location, data.context));
+        let result = await this.callback(data.location, data.context);
         if (!Array.isArray(result)) {
             result = [result];
         }
@@ -21,7 +21,7 @@ class RequestButtons extends BaseEvent_1.BaseEvent {
         return result;
     }
     static async respond(bridge, buttons, id) {
-        let response = [];
+        const response = [];
         for (let i = 0, l = buttons.length; i < l; i++) {
             if (!(buttons[i] instanceof __1.Button)) {
                 throw new TypeError("Invalid response returned, expected button");

package/lib/Events/RequestCustomerListOptions.d.ts

@@ -1,12 +1,13 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { Bridge } from "..";
 import { BaseEvent } from "./BaseEvent";
+import { MaybePromise } from "../Utilities/MiscTypes";
 export interface SellScreenCustomerListOption {
     contents: string;
     onClick: () => void;
 }
-export declare class RequestCustomerListOptions extends BaseEvent {
+export declare class RequestCustomerListOptions extends BaseEvent<Record<string, unknown>, MaybePromise<FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"]>, FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"], undefined> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_CUSTOMER_LIST_OPTIONS"]);
-    emit(data: {}): Promise<FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"]>;
+    emit(_: Record<string, unknown>): Promise<FromShopfrontReturns["REQUEST_CUSTOMER_LIST_OPTIONS"]>;
     static respond(bridge: Bridge, options: Array<SellScreenCustomerListOption>, id: string): Promise<void>;
 }

package/lib/Events/RequestCustomerListOptions.js

@@ -8,8 +8,9 @@ class RequestCustomerListOptions extends BaseEvent_1.BaseEvent {
     constructor(callback) {
         super(callback);
     }
-    async emit(data) {
-        let result = await Promise.resolve(this.callback());
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async emit(_) {
+        let result = await this.callback(undefined, undefined);
         if (!Array.isArray(result)) {
             result = [result];
         }

package/lib/Events/RequestSaleKeys.d.ts

@@ -2,7 +2,8 @@ import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEven
 import { Bridge } from "..";
 import { BaseEvent } from "./BaseEvent";
 import { SaleKey } from "../Actions/SaleKey";
-export declare class RequestSaleKeys extends BaseEvent {
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class RequestSaleKeys extends BaseEvent<undefined, MaybePromise<Array<SaleKey>>, Array<SaleKey>> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_SALE_KEYS"]);
     emit(): Promise<FromShopfrontReturns["REQUEST_SALE_KEYS"]>;
     static respond(bridge: Bridge, keys: Array<SaleKey>, id: string): Promise<void>;

package/lib/Events/RequestSaleKeys.js

@@ -9,7 +9,7 @@ class RequestSaleKeys extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit() {
-        let result = await Promise.resolve(this.callback());
+        let result = await this.callback(undefined, undefined);
         if (!Array.isArray(result)) {
             result = [result];
         }
@@ -21,7 +21,7 @@ class RequestSaleKeys extends BaseEvent_1.BaseEvent {
         return result;
     }
     static async respond(bridge, keys, id) {
-        let response = [];
+        const response = [];
         for (let i = 0, l = keys.length; i < l; i++) {
             if (!(keys[i] instanceof SaleKey_1.SaleKey)) {
                 throw new TypeError("Invalid response returned, expected SaleKey");

package/lib/Events/RequestSellScreenOptions.d.ts

@@ -1,15 +1,16 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { Bridge } from "..";
 import { BaseEvent } from "./BaseEvent";
+import { MaybePromise } from "../Utilities/MiscTypes";
 export interface SellScreenOption {
     url: string;
     title: string;
     id?: string;
 }
-export declare class RequestSellScreenOptions extends BaseEvent {
+export declare class RequestSellScreenOptions extends BaseEvent<undefined, MaybePromise<FromShopfrontReturns["REQUEST_SELL_SCREEN_OPTIONS"]>, FromShopfrontReturns["REQUEST_SELL_SCREEN_OPTIONS"]> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_SELL_SCREEN_OPTIONS"]);
     static getOptionId(url: string): string;
     static validateURL(url: string): void;
-    emit(data: {}): Promise<FromShopfrontReturns["REQUEST_SELL_SCREEN_OPTIONS"]>;
+    emit(_: never): Promise<FromShopfrontReturns["REQUEST_SELL_SCREEN_OPTIONS"]>;
     static respond(bridge: Bridge, options: Array<SellScreenOption>, id: string): Promise<void>;
 }

package/lib/Events/RequestSellScreenOptions.js

@@ -22,8 +22,9 @@ class RequestSellScreenOptions extends BaseEvent_1.BaseEvent {
             throw new TypeError(`The URL "${url}" is invalid, please ensure that you're using the HTTPS protocol`);
         }
     }
-    async emit(data) {
-        let result = await Promise.resolve(this.callback());
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async emit(_) {
+        let result = await this.callback(undefined, undefined);
         if (!Array.isArray(result)) {
             result = [result];
         }

package/lib/Events/RequestSettings.d.ts

@@ -1,8 +1,9 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { BaseEvent } from "./BaseEvent";
 import { Bridge } from "../Bridge";
-export declare class RequestSettings extends BaseEvent {
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class RequestSettings extends BaseEvent<undefined, MaybePromise<FromShopfrontReturns["REQUEST_SETTINGS"]>, FromShopfrontReturns["REQUEST_SETTINGS"]> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_SETTINGS"]);
-    emit(data: {}): Promise<FromShopfrontReturns["REQUEST_SETTINGS"]>;
+    emit(_: never): Promise<FromShopfrontReturns["REQUEST_SETTINGS"]>;
     static respond(bridge: Bridge, settings: Array<FromShopfrontReturns["REQUEST_SETTINGS"]>, id: string): Promise<void>;
 }

package/lib/Events/RequestSettings.js

@@ -7,8 +7,9 @@ class RequestSettings extends BaseEvent_1.BaseEvent {
     constructor(callback) {
         super(callback);
     }
-    async emit(data) {
-        const result = await Promise.resolve(this.callback());
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async emit(_) {
+        const result = await this.callback(undefined, undefined);
         if (typeof result !== "object" || result === null) {
             throw new TypeError("Callback must return an object");
         }

package/lib/Events/RequestTableColumns.d.ts

@@ -1,11 +1,15 @@
 import { FromShopfrontCallbacks, FromShopfrontReturns } from "../ApplicationEvents";
 import { BaseEvent } from "./BaseEvent";
 import { Bridge } from "../Bridge";
-export declare class RequestTableColumns extends BaseEvent {
+import { MaybePromise } from "../Utilities/MiscTypes";
+export declare class RequestTableColumns extends BaseEvent<{
+    location: string;
+    context: unknown;
+}, MaybePromise<FromShopfrontReturns["REQUEST_TABLE_COLUMNS"]>, FromShopfrontReturns["REQUEST_TABLE_COLUMNS"], string, unknown> {
     constructor(callback: FromShopfrontCallbacks["REQUEST_TABLE_COLUMNS"]);
     emit(data: {
         location: string;
-        context: any;
+        context: unknown;
     }): Promise<FromShopfrontReturns["REQUEST_TABLE_COLUMNS"]>;
     static respond(bridge: Bridge, columns: Array<FromShopfrontReturns["REQUEST_TABLE_COLUMNS"]>, id: string): Promise<void>;
 }

package/lib/Events/RequestTableColumns.js

@@ -8,7 +8,7 @@ class RequestTableColumns extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        const result = await Promise.resolve(this.callback(data.location, data.context));
+        const result = await this.callback(data.location, data.context);
         if (typeof result !== "object") {
             throw new TypeError("Callback must return an object");
         }

package/lib/Events/SaleComplete.d.ts

@@ -57,7 +57,7 @@ interface CompletedSaleProduct {
     requestPrice?: boolean;
     lockQuantity: boolean;
     metaData: {
-        [key: string]: any;
+        [key: string]: unknown;
     };
 }
 interface CompletedSalePayment {

package/lib/Events/SaleComplete.js

@@ -7,7 +7,7 @@ class SaleComplete extends BaseEvent_1.BaseEvent {
         super(callback);
     }
     async emit(data) {
-        this.callback(data);
+        this.callback(data, undefined);
     }
 }
 exports.SaleComplete = SaleComplete;

package/lib/Events/UIPipeline.d.ts

@@ -0,0 +1,15 @@
+import { BaseEvent } from "./BaseEvent";
+import { FromShopfrontCallbacks, FromShopfrontReturns, UIPipelineBaseContext, UIPipelineContext, UIPipelineResponse } from "../ApplicationEvents";
+import { Bridge } from "../Bridge";
+import { MaybePromise } from "../Utilities/MiscTypes";
+interface UIPPipelineIncomingData {
+    data: Array<UIPipelineResponse>;
+    context: UIPipelineBaseContext;
+    pipelineId?: string;
+}
+export declare class UIPipeline extends BaseEvent<UIPPipelineIncomingData, MaybePromise<FromShopfrontReturns["UI_PIPELINE"]>, FromShopfrontReturns["UI_PIPELINE"], Array<UIPipelineResponse>, UIPipelineContext> {
+    constructor(callback: FromShopfrontCallbacks["UI_PIPELINE"]);
+    emit(data: UIPPipelineIncomingData, bridge: Bridge): Promise<FromShopfrontReturns["UI_PIPELINE"]>;
+    static respond(bridge: Bridge, data: FromShopfrontReturns["UI_PIPELINE"], id: string): Promise<void>;
+}
+export {};