@aptos-scp/scp-component-store-selling-features-domain-model 1.0.0

package/lib/domain/model/StoredValueCardSession.d.ts

@@ -0,0 +1,29 @@
+import { IState } from "@aptos-scp/scp-component-store-selling-core";
+import { ValueCardAction } from "./tender/valueCard";
+export declare const STORED_VALUE_SESSION: string;
+/**
+ * Only kept for compatibility. Use STORED_VALUE_SESSION instead
+ */
+export declare const STORED_VALUE_CARD_SESSION: string;
+export declare enum StoredValueCardSessionState {
+    InProgress = "InProgress",
+    Completed = "Completed",
+    ReversalInProgress = "ReversalInProgress"
+}
+export declare class StoredValueCardSession implements IState {
+    private readonly _type;
+    private readonly _state;
+    private readonly _action;
+    static createFromJsonObject(resumeSessionJsonObj: any): StoredValueCardSession;
+    static create(): StoredValueCardSession;
+    get type(): string;
+    get action(): ValueCardAction;
+    get inProgress(): boolean;
+    get isCompleted(): boolean;
+    get isReversalInProgress(): boolean;
+    get stateValues(): Readonly<Map<string, any>>;
+    startAction(action: ValueCardAction): StoredValueCardSession;
+    complete(): StoredValueCardSession;
+    startReversal(action: ValueCardAction): StoredValueCardSession;
+    private constructor();
+}

package/lib/domain/model/StoredValueCardSession.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.StoredValueCardSession");
+exports.STORED_VALUE_SESSION = "StoredValueSession";
+/**
+ * Only kept for compatibility. Use STORED_VALUE_SESSION instead
+ */
+exports.STORED_VALUE_CARD_SESSION = "StoredValueCardSession";
+var StoredValueCardSessionState;
+(function (StoredValueCardSessionState) {
+    StoredValueCardSessionState["InProgress"] = "InProgress";
+    StoredValueCardSessionState["Completed"] = "Completed";
+    StoredValueCardSessionState["ReversalInProgress"] = "ReversalInProgress";
+})(StoredValueCardSessionState = exports.StoredValueCardSessionState || (exports.StoredValueCardSessionState = {}));
+class StoredValueCardSession {
+    constructor(state, action) {
+        this._type = exports.STORED_VALUE_SESSION;
+        this._state = state;
+        this._action = action;
+    }
+    static createFromJsonObject(resumeSessionJsonObj) {
+        logger.traceEntry("createFromJsonObject");
+        const state = resumeSessionJsonObj._state;
+        const action = resumeSessionJsonObj._action;
+        return new StoredValueCardSession(state, action);
+    }
+    static create() {
+        logger.traceEntry("create");
+        return new StoredValueCardSession(StoredValueCardSessionState.Completed);
+    }
+    get type() {
+        return this._type;
+    }
+    get action() {
+        return this._action;
+    }
+    get inProgress() {
+        return this._state === StoredValueCardSessionState.InProgress;
+    }
+    get isCompleted() {
+        return this._state === StoredValueCardSessionState.Completed;
+    }
+    get isReversalInProgress() {
+        return this._state === StoredValueCardSessionState.ReversalInProgress;
+    }
+    get stateValues() {
+        logger.traceEntry("get stateValues");
+        return new Map([
+            ["StoredValueCardSession.action", this._action],
+            ["StoredValueCardSession.state", this._state],
+        ]);
+    }
+    startAction(action) {
+        return new StoredValueCardSession(StoredValueCardSessionState.InProgress, action);
+    }
+    complete() {
+        return new StoredValueCardSession(StoredValueCardSessionState.Completed);
+    }
+    startReversal(action) {
+        return new StoredValueCardSession(StoredValueCardSessionState.ReversalInProgress, action);
+    }
+}
+exports.StoredValueCardSession = StoredValueCardSession;
+//# sourceMappingURL=StoredValueCardSession.js.map

package/lib/domain/model/StoredValueCertificateSession.d.ts

@@ -0,0 +1,47 @@
+import { Money } from "@aptos-scp/scp-component-business-core";
+import { IState } from "@aptos-scp/scp-component-store-selling-core";
+import { ValueCertSubType } from "@aptos-scp/scp-types-commerce-devices";
+import { ValueCertificateAction } from "../model";
+import { MerchandiseTransaction } from "./MerchandiseTransaction";
+import { IValueCertificate } from "./tender";
+export declare const STORED_VALUE_CERTIFICATE_SESSION: string;
+export declare enum StoredValueCertificateSessionState {
+    InProgress = "InProgress",
+    Completed = "Completed",
+    ReversalInProgress = "ReversalInProgress"
+}
+export interface IValueCertificateInquiryResults {
+    totalApplied?: Money;
+    valueCertificates: IValueCertificateResult[];
+}
+export interface IValueCertificateResult {
+    accountNumber: string;
+    valueCertificateType: ValueCertSubType;
+    balance: Money;
+    appliedAmount?: Money;
+    tenderLineNumber?: number;
+    manuallyApplied?: boolean;
+}
+export declare class StoredValueCertificateSession implements IState {
+    private readonly _type;
+    private readonly _state;
+    private readonly _action;
+    private readonly _inquiryResults;
+    private readonly _lineNumber;
+    static createFromJsonObject(storedValueCertificateSessionJsonObj: any): StoredValueCertificateSession;
+    static create(): StoredValueCertificateSession;
+    get type(): string;
+    get action(): ValueCertificateAction;
+    get lineNumber(): number;
+    get inquiryResults(): IValueCertificateInquiryResults;
+    get inProgress(): boolean;
+    get isCompleted(): boolean;
+    get isReversalInProgress(): boolean;
+    get stateValues(): Readonly<Map<string, any>>;
+    startAction(action: ValueCertificateAction, lineNumber?: number): StoredValueCertificateSession;
+    complete(): StoredValueCertificateSession;
+    startReversal(action: ValueCertificateAction): StoredValueCertificateSession;
+    recordInquiry(valueCertificates: IValueCertificate[], transaction: MerchandiseTransaction): StoredValueCertificateSession;
+    clearInquiry(): StoredValueCertificateSession;
+    private constructor();
+}

package/lib/domain/model/StoredValueCertificateSession.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_business_core_1 = require("@aptos-scp/scp-component-business-core");
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const Constants_1 = require("./Constants");
+const tender_1 = require("./tender");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.StoredValueCertificateSession");
+exports.STORED_VALUE_CERTIFICATE_SESSION = "StoredValueCertificateSession";
+var StoredValueCertificateSessionState;
+(function (StoredValueCertificateSessionState) {
+    StoredValueCertificateSessionState["InProgress"] = "InProgress";
+    StoredValueCertificateSessionState["Completed"] = "Completed";
+    StoredValueCertificateSessionState["ReversalInProgress"] = "ReversalInProgress";
+})(StoredValueCertificateSessionState = exports.StoredValueCertificateSessionState || (exports.StoredValueCertificateSessionState = {}));
+class StoredValueCertificateSession {
+    constructor(state, action, inquiryResults, lineNumber) {
+        this._type = exports.STORED_VALUE_CERTIFICATE_SESSION;
+        this._state = state;
+        this._action = action;
+        this._inquiryResults = inquiryResults;
+        this._lineNumber = lineNumber;
+    }
+    static createFromJsonObject(storedValueCertificateSessionJsonObj) {
+        logger.traceEntry("createFromJsonObject");
+        const state = storedValueCertificateSessionJsonObj._state;
+        const action = storedValueCertificateSessionJsonObj._action;
+        const lineNumber = storedValueCertificateSessionJsonObj._lineNumber;
+        const inquiryResults = storedValueCertificateSessionJsonObj._inquiryResults &&
+            loadInquiryResultsFromJson(storedValueCertificateSessionJsonObj._inquiryResults);
+        return new StoredValueCertificateSession(state, action, inquiryResults, lineNumber);
+    }
+    static create() {
+        logger.traceEntry("create");
+        return new StoredValueCertificateSession(StoredValueCertificateSessionState.Completed);
+    }
+    get type() {
+        return this._type;
+    }
+    get action() {
+        return this._action;
+    }
+    get lineNumber() {
+        return this._lineNumber;
+    }
+    get inquiryResults() {
+        return this._inquiryResults;
+    }
+    get inProgress() {
+        return this._state === StoredValueCertificateSessionState.InProgress;
+    }
+    get isCompleted() {
+        return this._state === StoredValueCertificateSessionState.Completed;
+    }
+    get isReversalInProgress() {
+        return this._state === StoredValueCertificateSessionState.ReversalInProgress;
+    }
+    get stateValues() {
+        logger.traceEntry("get stateValues");
+        return new Map([
+            ["StoredValueCertificateSession.action", this._action],
+            ["StoredValueCertificateSession.state", this._state],
+            ["StoredValueCertificateSession.inquiryResults", this._inquiryResults],
+            ["StoredValueCertificateSession.lineNumber", this._lineNumber],
+        ]);
+    }
+    startAction(action, lineNumber) {
+        return new StoredValueCertificateSession(StoredValueCertificateSessionState.InProgress, action, this._inquiryResults, lineNumber);
+    }
+    complete() {
+        return new StoredValueCertificateSession(StoredValueCertificateSessionState.Completed, undefined, this._inquiryResults);
+    }
+    startReversal(action) {
+        return new StoredValueCertificateSession(StoredValueCertificateSessionState.ReversalInProgress, action, this._inquiryResults);
+    }
+    recordInquiry(valueCertificates, transaction) {
+        return new StoredValueCertificateSession(this._state, this._action, buildInquiryResults(valueCertificates, transaction));
+    }
+    clearInquiry() {
+        return new StoredValueCertificateSession(this._state, this._action);
+    }
+}
+exports.StoredValueCertificateSession = StoredValueCertificateSession;
+function buildInquiryResults(valueCertificates, transaction) {
+    let valueCertificateResults = (valueCertificates && valueCertificates.map(convertValueCertificate)) || [];
+    let totalApplied;
+    const previouslyAppliedCertificateLines = transaction.lines.filter((line) => {
+        return (tender_1.isTenderPaymentLine(line) &&
+            !line.voided &&
+            line.tenderAuthCategory === Constants_1.TenderAuthCategory.StoredValueCertificateService);
+    });
+    if (previouslyAppliedCertificateLines && previouslyAppliedCertificateLines.length > 0) {
+        const previouslyAppliedCertificateResults = previouslyAppliedCertificateLines.map(convertTenderLinesToResult);
+        valueCertificateResults = [...valueCertificateResults, ...previouslyAppliedCertificateResults];
+        totalApplied = calculatePreviouslyApplied(previouslyAppliedCertificateLines);
+    }
+    return {
+        totalApplied,
+        valueCertificates: valueCertificateResults,
+    };
+}
+function convertValueCertificate(valueCertificate) {
+    var _a, _b, _c;
+    return {
+        balance: ((_a = valueCertificate) === null || _a === void 0 ? void 0 : _a.balance) && scp_component_business_core_1.Money.fromIMoney(valueCertificate.balance),
+        accountNumber: (_b = valueCertificate) === null || _b === void 0 ? void 0 : _b.accountNumber,
+        valueCertificateType: tender_1.valueCertificateTypeMapper().get((_c = valueCertificate) === null || _c === void 0 ? void 0 : _c.valueCertificateType),
+    };
+}
+function convertTenderLinesToResult(tenderLine) {
+    return {
+        accountNumber: tenderLine.authResponse.valueCertificateNumber,
+        balance: tenderLine.authResponse.balance,
+        appliedAmount: tenderLine.tenderAmount,
+        valueCertificateType: tenderLine.tenderType.subType,
+        tenderLineNumber: tenderLine.lineNumber,
+    };
+}
+function calculatePreviouslyApplied(tenderLines) {
+    let totalApplied;
+    tenderLines.forEach((line) => {
+        if (tender_1.isTenderPaymentLine(line)) {
+            if (!totalApplied) {
+                totalApplied = line.tenderAmount;
+            }
+            else {
+                totalApplied = totalApplied.plus(line.tenderAmount);
+            }
+        }
+    });
+    return totalApplied;
+}
+function loadInquiryResultsFromJson(inquiryResultsJson) {
+    return {
+        totalApplied: inquiryResultsJson.totalApplied && scp_component_business_core_1.Money.fromIMoney(inquiryResultsJson.totalApplied),
+        valueCertificates: loadValueCertificatesFromJson(inquiryResultsJson.valueCertificates),
+    };
+}
+function loadValueCertificatesFromJson(valueCertificatesJson) {
+    var _a;
+    let valueCertificates = [];
+    valueCertificates = (_a = valueCertificatesJson) === null || _a === void 0 ? void 0 : _a.map((valueCertificateJson) => {
+        return {
+            accountNumber: valueCertificateJson.accountNumber,
+            valueCertificateType: valueCertificateJson.valueCertificateType,
+            balance: valueCertificateJson.balance && scp_component_business_core_1.Money.fromIMoney(valueCertificateJson.balance),
+            appliedAmount: valueCertificateJson.appliedAmount && scp_component_business_core_1.Money.fromIMoney(valueCertificateJson.appliedAmount),
+            tenderLineNumber: valueCertificateJson.tenderLineNumber,
+            manuallyApplied: valueCertificateJson.manuallyApplied,
+        };
+    });
+    return valueCertificates;
+}
+//# sourceMappingURL=StoredValueCertificateSession.js.map

package/lib/domain/model/SubscriptionTokenSession.d.ts

@@ -0,0 +1,22 @@
+import { IState, ITransactionLine } from "@aptos-scp/scp-component-store-selling-core";
+export declare const SUBSCRIPTION_TOKEN_SESSION: string;
+export declare enum SubscriptionTokenSessionState {
+    NoTokenRequired = "NoTokenRequired",
+    RequiresToken = "RequiresToken"
+}
+export declare class SubscriptionTokenSession implements IState {
+    private readonly _type;
+    private readonly _state;
+    private readonly _subscriptionTokenLine;
+    private readonly _paymentTenderLine;
+    static createFromJsonObject(SubscriptionTokenSessionJsonObj: any): SubscriptionTokenSession;
+    static create(): SubscriptionTokenSession;
+    get type(): string;
+    get stateValues(): Readonly<Map<string, any>>;
+    get RequiresToken(): boolean;
+    get subscriptionTokenLine(): ITransactionLine;
+    get paymentTenderLine(): ITransactionLine;
+    updateSubscriptionToken(state: SubscriptionTokenSessionState, subscriptionTokenLine?: ITransactionLine, paymentTenderLine?: ITransactionLine): SubscriptionTokenSession;
+    complete(): SubscriptionTokenSession;
+    private constructor();
+}

package/lib/domain/model/SubscriptionTokenSession.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const tender_1 = require("./tender");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.SubscriptionTokenSession");
+exports.SUBSCRIPTION_TOKEN_SESSION = "SubscriptionTokenSession";
+var SubscriptionTokenSessionState;
+(function (SubscriptionTokenSessionState) {
+    SubscriptionTokenSessionState["NoTokenRequired"] = "NoTokenRequired";
+    SubscriptionTokenSessionState["RequiresToken"] = "RequiresToken";
+})(SubscriptionTokenSessionState = exports.SubscriptionTokenSessionState || (exports.SubscriptionTokenSessionState = {}));
+class SubscriptionTokenSession {
+    constructor(state, subscriptionTokenLine, paymentTenderLine) {
+        this._type = exports.SUBSCRIPTION_TOKEN_SESSION;
+        this._state = state;
+        this._subscriptionTokenLine = subscriptionTokenLine;
+        this._paymentTenderLine = paymentTenderLine;
+    }
+    static createFromJsonObject(SubscriptionTokenSessionJsonObj) {
+        logger.traceEntry("createFromJsonObject");
+        const state = SubscriptionTokenSessionJsonObj._state;
+        const paymentTenderLineJson = SubscriptionTokenSessionJsonObj._paymentTenderLine;
+        const subscriptionTokenLineJson = SubscriptionTokenSessionJsonObj._subscriptionTokenLine;
+        const paymentTenderLine = paymentTenderLineJson && tender_1.TenderLine.createFromJsonObject(paymentTenderLineJson);
+        const subscriptionTokenLine = subscriptionTokenLineJson && tender_1.TenderLine.createFromJsonObject(subscriptionTokenLineJson);
+        return new SubscriptionTokenSession(state, subscriptionTokenLine, paymentTenderLine);
+    }
+    static create() {
+        logger.traceEntry("create");
+        return new SubscriptionTokenSession(SubscriptionTokenSessionState.NoTokenRequired);
+    }
+    get type() {
+        return this._type;
+    }
+    get stateValues() {
+        logger.traceEntry("get stateValues");
+        return new Map([
+            ["SubscriptionTokenSession.state", this._state],
+            ["SubscriptionTokenSession.subscriptionTokenLine", this._subscriptionTokenLine],
+            ["SubscriptionTokenSession.paymentTenderLine", this._paymentTenderLine],
+        ]);
+    }
+    get RequiresToken() {
+        return this._state === SubscriptionTokenSessionState.RequiresToken;
+    }
+    get subscriptionTokenLine() {
+        return this._subscriptionTokenLine;
+    }
+    get paymentTenderLine() {
+        return this._paymentTenderLine;
+    }
+    updateSubscriptionToken(state, subscriptionTokenLine, paymentTenderLine) {
+        return new SubscriptionTokenSession(state, subscriptionTokenLine, paymentTenderLine);
+    }
+    complete() {
+        return new SubscriptionTokenSession(SubscriptionTokenSessionState.NoTokenRequired);
+    }
+}
+exports.SubscriptionTokenSession = SubscriptionTokenSession;
+//# sourceMappingURL=SubscriptionTokenSession.js.map

package/lib/domain/model/Subscriptions.d.ts

@@ -0,0 +1,12 @@
+import { ITimeInterval } from "@aptos-scp/scp-types-commerce-transaction";
+export interface ISubscriptionInfo {
+    lineNumber: number;
+    subscribed: boolean;
+    frequency: IFrequencyInfo;
+    quantity: number;
+    deliveryfrequencyDescription: string;
+}
+export interface IFrequencyInfo {
+    code?: string;
+    timeInterval?: ITimeInterval;
+}

package/lib/domain/model/Subscriptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=Subscriptions.js.map

package/lib/domain/model/TaxRefundControlTransaction.d.ts

@@ -0,0 +1,13 @@
+import { DeviceIdentity, ITransaction, ITransactionLine, ITransactionLineFactory, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { RetailTransaction } from "./RetailTransaction";
+export declare const TAX_REFUND_CONTROL_TRANSACTION_TYPE = "TaxRefundControlTransaction";
+export declare class TaxRefundControlTransaction extends RetailTransaction {
+    static createFromJsonObj(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): TaxRefundControlTransaction;
+    constructor(deviceIdentity: DeviceIdentity, businessDayDate: string, transactionNumber: number, user?: IUser, transactionId?: string);
+    clone(): ITransaction;
+    get transactionStateValues(): Readonly<Map<string, any>>;
+    findLineByLineNumber(lineNumber: number): ITransactionLine;
+    protected newTransaction(): RetailTransaction;
+    protected loadFromJsonObject(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): void;
+}
+export declare const isTaxRefundControlTransaction: (transaction: ITransaction) => transaction is TaxRefundControlTransaction;

package/lib/domain/model/TaxRefundControlTransaction.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const config_1 = require("../../config");
+const RetailTransaction_1 = require("./RetailTransaction");
+exports.TAX_REFUND_CONTROL_TRANSACTION_TYPE = "TaxRefundControlTransaction";
+class TaxRefundControlTransaction extends RetailTransaction_1.RetailTransaction {
+    static createFromJsonObj(transactionJsonObj, transactionLineFactory) {
+        const transactionId = RetailTransaction_1.RetailTransaction.getTransactionIdFromJsonObject(transactionJsonObj);
+        const deviceIdentity = RetailTransaction_1.RetailTransaction.getDeviceIdentityFromJsonObject(transactionJsonObj);
+        const businessDayDate = RetailTransaction_1.RetailTransaction.getBusinessDayDateFromJsonObject(transactionJsonObj);
+        const transactionNumber = RetailTransaction_1.RetailTransaction.getTransactionNumberFromJsonObject(transactionJsonObj);
+        const performingUser = RetailTransaction_1.RetailTransaction.getPerformingUserFromJsonObject(transactionJsonObj);
+        const transaction = new TaxRefundControlTransaction(deviceIdentity, businessDayDate, transactionNumber, performingUser, transactionId);
+        transaction.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        return transaction;
+    }
+    constructor(deviceIdentity, businessDayDate, transactionNumber, user, transactionId) {
+        super(deviceIdentity, businessDayDate, transactionNumber, exports.TAX_REFUND_CONTROL_TRANSACTION_TYPE, user, transactionId);
+    }
+    clone() {
+        const transaction = super.clone();
+        if (!exports.isTaxRefundControlTransaction(transaction)) {
+            throw new scp_component_store_selling_core_1.PosError("Cannot clone TaxRefundControlTransaction, because new " +
+                "instance is not a TaxRefundControlTransaction.", config_1.SSF_TRANSACTION_ERROR_CODE);
+        }
+        return transaction;
+    }
+    get transactionStateValues() {
+        return new Map([...super.transactionStateValues.entries()]);
+    }
+    findLineByLineNumber(lineNumber) {
+        if (lineNumber && super.lines.length > 0) {
+            return super.findLineByLineNumber(lineNumber);
+        }
+        return undefined;
+    }
+    newTransaction() {
+        return new TaxRefundControlTransaction(this.deviceIdentity, this.businessDayDate, this.transactionNumber, this.performingUser, this.transactionId);
+    }
+    loadFromJsonObject(transactionJsonObj, transactionLineFactory) {
+        super.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+    }
+}
+exports.TaxRefundControlTransaction = TaxRefundControlTransaction;
+exports.isTaxRefundControlTransaction = (transaction) => {
+    return (transaction instanceof TaxRefundControlTransaction ||
+        transaction.transactionType === exports.TAX_REFUND_CONTROL_TRANSACTION_TYPE);
+};
+//# sourceMappingURL=TaxRefundControlTransaction.js.map

package/lib/domain/model/TenderAuthorizationSession.d.ts

@@ -0,0 +1,102 @@
+import { Money } from "@aptos-scp/scp-component-business-core";
+import { IState, UiInput } from "@aptos-scp/scp-component-store-selling-core";
+import { TenderAuthCategory } from "./Constants";
+import { IOfflineAuthorizationFields } from "./tender/OfflineAuthorization";
+export declare enum TenderAuthorizationState {
+    InProgress = "InProgress",
+    WaitingForSignature = "WaitingForSignature",
+    WaitingForReversal = "WaitingForReversal",
+    WaitingForTransactionVoid = "WaitingForTransactionVoid",
+    WaitingForCallforAuthorization = "WaitingForCallforAuthorization",
+    Completed = "Completed",
+    BalanceInquiryInProgress = "BalanceInquiryInProgress",
+    GiftCardIssueInProgress = "GiftCardIssueInProgress",
+    GiftCardRefundInProgress = "GiftCardRefundInProgress",
+    WaitingForPartialAuthorizationApproval = "waitingForPartialAuthorizationApproval",
+    WaitingForRetryLastAuthorization = "WaitingForRetryLastAuthorization",
+    WaitingForNonIntegratedInput = "WaitingForNonIntegratedInput",
+    WaitingForTenderAuthManualReversal = "WaitingForTenderAuthManualReversal",
+    CancelInProgress = "CancelInProgress",
+    TokenRetrievalInProgress = "TokenRetrievalInProgress",
+    TenderVoidInProgress = "TenderVoidInProgress",
+    WaitingForCashoutConfirmation = "WaitingForCashoutConfirmation"
+}
+export declare enum AuthorizationMode {
+    Item = "Item",
+    Tender = "Tender"
+}
+export declare const TENDER_AUTH_SESSION: string;
+export interface INonIntegratedFields {
+    tenderAmount: Money;
+    deviceId: string;
+    lineNumber: number;
+    tenderAuthCategory: TenderAuthCategory;
+    originalTenderId?: string;
+    mappedRefundTenderTypeName?: string;
+}
+export declare class TenderAuthorizationSession implements IState {
+    private readonly _type;
+    private readonly _state;
+    private readonly _lineNumber;
+    private readonly _offlineAuthorizationFields;
+    private readonly _authorizationMode;
+    private readonly _inputs;
+    private readonly _nonIntegratedFields;
+    private readonly _requiredInputs;
+    private readonly _cashoutAmount;
+    private readonly _cashoutThreshold;
+    private readonly _tenderAuthCategory;
+    static createFromJsonObject(tenderAuthorizationSessionJsonObj: any): TenderAuthorizationSession;
+    static create(): TenderAuthorizationSession;
+    get type(): string;
+    get lineNumber(): number;
+    get offlineAuthorizationFields(): IOfflineAuthorizationFields;
+    get authorizationAmount(): Money;
+    get authorizationMode(): AuthorizationMode;
+    get state(): TenderAuthorizationState;
+    get inputs(): UiInput[];
+    get nonIntegratedFields(): INonIntegratedFields;
+    get cashoutAmount(): Money;
+    get cashoutThreshold(): Money;
+    get requiredInputs(): any[];
+    get tenderAuthCategory(): TenderAuthCategory;
+    get stateValues(): Readonly<Map<string, any>>;
+    get inProgress(): boolean;
+    get inWaitingForSignature(): boolean;
+    get inWaitingForCashoutConfirmation(): boolean;
+    get inWaitingForReversal(): boolean;
+    get inWaitingForCallforAuthorization(): boolean;
+    get inWaitingForRetryLastAuthorization(): boolean;
+    get inWaitingForTenderAuthManualReversal(): boolean;
+    get inCancelInProgress(): boolean;
+    get completed(): boolean;
+    get inBalanceInquiryInProgress(): boolean;
+    get inGiftCardIssueInProgress(): boolean;
+    get inGiftCardRefundInProgress(): boolean;
+    get inWaitingForPartialAuthorizationApproval(): boolean;
+    get inWaitingForTransactionVoid(): boolean;
+    get inWaitingForNonIntegratedInput(): boolean;
+    get inTokenRetrievalInProgress(): boolean;
+    get inTenderVoidInProgress(): boolean;
+    get isAuthorizationDeviceActive(): boolean;
+    startAuthorization(lineNumber: number, tenderAuthCategory?: TenderAuthCategory): TenderAuthorizationSession;
+    startInProgress(lineNumber: number, tenderAuthCategory: TenderAuthCategory, authorizationMode?: AuthorizationMode): TenderAuthorizationSession;
+    startTenderVoid(lineNumber: number, tenderAuthCategory: TenderAuthCategory): TenderAuthorizationSession;
+    startBalanceInquiry(lineNumber: number): TenderAuthorizationSession;
+    startGiftCardIssue(lineNumber: number): TenderAuthorizationSession;
+    startGiftCardRefund(lineNumber: number): TenderAuthorizationSession;
+    startWaitingForPartialAuthorizationApproval(lineNumber: number): TenderAuthorizationSession;
+    waitForSignature(): TenderAuthorizationSession;
+    waitForCashoutConfirmation(lineNumber: number, amount?: Money, threshold?: Money): TenderAuthorizationSession;
+    waitForCallforAuthorization(lineNumber: number, offlineAuthorizationFields: IOfflineAuthorizationFields, authorizationMode: AuthorizationMode): TenderAuthorizationSession;
+    waitForTokenRetrieval(lineNumber: number): TenderAuthorizationSession;
+    waitForRetryLastAuthorization(lineNumber: number): TenderAuthorizationSession;
+    waitForNonIntegratedInput(lineNumber: number, requiredInputs: any[], nonIntegratedFields?: INonIntegratedFields): TenderAuthorizationSession;
+    waitForTenderAuthManualReversal(lineNumber: number): TenderAuthorizationSession;
+    startTenderAuthManualReversal(lineNumber: number): TenderAuthorizationSession;
+    startReversal(lineNumber: number): TenderAuthorizationSession;
+    saveInputs(uiInputs: UiInput[]): TenderAuthorizationSession;
+    stop(): TenderAuthorizationSession;
+    startVoidTransaction(lineNumber: number): TenderAuthorizationSession;
+    private constructor();
+}