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

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

@@ -0,0 +1,87 @@
+import { IState, Receipt } from "@aptos-scp/scp-component-store-selling-core";
+import { ReceiptType } from "./Constants";
+import { ILastRetailTransactionInfo } from "./ILastRetailTransactionInfo";
+export declare enum ReceiptState {
+    WaitingForOptions = "WaitingForOptions",
+    WaitingForReceipt = "WaitingForReceipt",
+    WaitingForPrinting = "WaitingForPrinting",
+    Completed = "Completed",
+    Inactive = "Inactive"
+}
+export declare enum ReceiptCategory {
+    Suspend = "Suspend",
+    Void = "Void",
+    BalanceInquiry = "BalanceInquiry",
+    Coupon = "Coupon",
+    NoSale = "NoSale",
+    PaidOperation = "PaidOperation",
+    ReprintReceipt = "ReprintReceipt",
+    Receipt = "Receipt",
+    Gift = "Gift",
+    Shipping = "Shipping",
+    PostVoid = "PostVoid",
+    VatReceipt = "VatReceipt",
+    Invoice = "Invoice",
+    StoreTender = "StoreTender",
+    Till = "Till",
+    StoreReturns = "StoreReturns",
+    FullPageInvoice = "FullPageInvoice",
+    TenderExchange = "TenderExchange",
+    JapanRSSReceipt = "JapanRSSReceipt",
+    StoreInvoice = "StoreInvoice",
+    StoreReceipt = "StoreReceipt",
+    VoidedTender = "VoidedTender",
+    DeclineTender = "DeclineTender",
+    VoidTenderFailed = "VoidTenderFailed",
+    VoidTenderPending = "VoidTenderPending"
+}
+export declare const PrinterRequiredCategories: ReceiptCategory[];
+export declare const RECEIPT_SESSION: string;
+export interface IReceiptRequiredData {
+    lineNumber: number;
+    receiptCategory: ReceiptCategory;
+    nonFinancialReceiptData?: INonFinancialReceiptRequiredData;
+}
+export interface INonFinancialReceiptRequiredData {
+    printedCouponNumber: string;
+    printedCouponValidUntilDate: string;
+    textLines: string[];
+}
+export declare class ReceiptSession implements IState {
+    private readonly _type;
+    private readonly _state;
+    private readonly _receiptCategory;
+    private readonly _receiptType;
+    private readonly _printerRequired;
+    private readonly _receipt;
+    private readonly _lineNumbers;
+    private readonly _printingFailed;
+    private readonly _printerId;
+    private readonly _receiptRequiredData;
+    static createFromJsonObject(ReceiptSessionJsonObj: any): ReceiptSession;
+    static create(): ReceiptSession;
+    get type(): string;
+    get state(): ReceiptState;
+    get receiptCategory(): ReceiptCategory;
+    get receiptType(): ReceiptType;
+    get printerRequired(): boolean;
+    get receipt(): Receipt;
+    get lineNumbers(): any;
+    get receiptRequiredData(): IReceiptRequiredData[];
+    get printingFailed(): boolean;
+    get printerId(): string;
+    get stateValues(): Readonly<Map<string, any>>;
+    get inWaitingForOptions(): boolean;
+    get inWaitingForReceipt(): boolean;
+    get inWaitingForReceiptForLineNumbers(): boolean;
+    get inWaitingForPrinting(): boolean;
+    get completed(): boolean;
+    get isInactive(): boolean;
+    collectReceiptOptions(receiptCategory?: ReceiptCategory, printerRequired?: boolean, receiptRequiredLineNumber?: number): ReceiptSession;
+    generate(receiptType: ReceiptType): ReceiptSession;
+    printStarted(receipt: Receipt, lineNumber: number): ReceiptSession;
+    stop(printingFailed?: boolean, printerId?: string): ReceiptSession;
+    reset(): ReceiptSession;
+    private constructor();
+}
+export declare function getReceiptCategoryFromLastTransaction(lastTransaction: ILastRetailTransactionInfo): ReceiptCategory;

package/lib/domain/model/ReceiptSession.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const scp_types_commerce_transaction_1 = require("@aptos-scp/scp-types-commerce-transaction");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storesellingfeatures.domain.model.ReceiptSession");
+var ReceiptState;
+(function (ReceiptState) {
+    ReceiptState["WaitingForOptions"] = "WaitingForOptions";
+    ReceiptState["WaitingForReceipt"] = "WaitingForReceipt";
+    ReceiptState["WaitingForPrinting"] = "WaitingForPrinting";
+    ReceiptState["Completed"] = "Completed";
+    ReceiptState["Inactive"] = "Inactive";
+})(ReceiptState = exports.ReceiptState || (exports.ReceiptState = {}));
+var ReceiptCategory;
+(function (ReceiptCategory) {
+    ReceiptCategory["Suspend"] = "Suspend";
+    ReceiptCategory["Void"] = "Void";
+    ReceiptCategory["BalanceInquiry"] = "BalanceInquiry";
+    ReceiptCategory["Coupon"] = "Coupon";
+    ReceiptCategory["NoSale"] = "NoSale";
+    ReceiptCategory["PaidOperation"] = "PaidOperation";
+    ReceiptCategory["ReprintReceipt"] = "ReprintReceipt";
+    ReceiptCategory["Receipt"] = "Receipt";
+    ReceiptCategory["Gift"] = "Gift";
+    ReceiptCategory["Shipping"] = "Shipping";
+    ReceiptCategory["PostVoid"] = "PostVoid";
+    ReceiptCategory["VatReceipt"] = "VatReceipt";
+    ReceiptCategory["Invoice"] = "Invoice";
+    ReceiptCategory["StoreTender"] = "StoreTender";
+    ReceiptCategory["Till"] = "Till";
+    ReceiptCategory["StoreReturns"] = "StoreReturns";
+    ReceiptCategory["FullPageInvoice"] = "FullPageInvoice";
+    ReceiptCategory["TenderExchange"] = "TenderExchange";
+    ReceiptCategory["JapanRSSReceipt"] = "JapanRSSReceipt";
+    ReceiptCategory["StoreInvoice"] = "StoreInvoice";
+    ReceiptCategory["StoreReceipt"] = "StoreReceipt";
+    ReceiptCategory["VoidedTender"] = "VoidedTender";
+    ReceiptCategory["DeclineTender"] = "DeclineTender";
+    ReceiptCategory["VoidTenderFailed"] = "VoidTenderFailed";
+    ReceiptCategory["VoidTenderPending"] = "VoidTenderPending";
+})(ReceiptCategory = exports.ReceiptCategory || (exports.ReceiptCategory = {}));
+exports.PrinterRequiredCategories = [
+    ReceiptCategory.StoreTender,
+    ReceiptCategory.Gift,
+    ReceiptCategory.Shipping,
+    ReceiptCategory.StoreReturns,
+    ReceiptCategory.StoreInvoice,
+    ReceiptCategory.StoreReceipt,
+    ReceiptCategory.DeclineTender,
+    ReceiptCategory.VoidedTender,
+    ReceiptCategory.VoidTenderFailed,
+    ReceiptCategory.Coupon,
+];
+exports.RECEIPT_SESSION = "ReceiptSession";
+const ReceiptStateNumericMap = {
+    0: "WaitingForOptions",
+    1: "WaitingForReceipt",
+    2: "WaitingForPrinting",
+    3: "Completed",
+};
+class ReceiptSession {
+    constructor(state, receiptCategory, receiptType, receipt, lineNumbers, printerRequired, printingFailed, printerId, receiptRequiredData) {
+        // Line numbers for the receipt lines while waiting for printing
+        this._lineNumbers = [];
+        // Line numbers that we need to print receipt(s) for
+        this._receiptRequiredData = [];
+        this._type = exports.RECEIPT_SESSION;
+        this._state = state;
+        this._receiptCategory = receiptCategory;
+        this._receiptType = receiptType;
+        this._receipt = receipt;
+        this._lineNumbers = lineNumbers;
+        this._printerRequired = printerRequired;
+        this._printingFailed = printingFailed;
+        this._printerId = printerId;
+        this._receiptRequiredData = receiptRequiredData;
+    }
+    static createFromJsonObject(ReceiptSessionJsonObj) {
+        logger.traceEntry("createFromJsonObject");
+        const state = typeof ReceiptSessionJsonObj._state === "number"
+            ? ReceiptStateNumericMap[ReceiptSessionJsonObj._state]
+            : ReceiptSessionJsonObj._state === "WaitingForPrintingOptions"
+                ? ReceiptState.WaitingForOptions
+                : ReceiptSessionJsonObj._state;
+        const receiptCategory = ReceiptSessionJsonObj._receiptCategory;
+        const receiptType = ReceiptSessionJsonObj._receiptType;
+        const receipt = ReceiptSessionJsonObj._receipt;
+        const lineNumber = ReceiptSessionJsonObj._lineNumbers;
+        const receiptRequiredData = ReceiptSessionJsonObj._receiptRequiredData;
+        const printerRequired = ReceiptSessionJsonObj._printerRequired;
+        const printingFailed = ReceiptSessionJsonObj._printingFailed;
+        const printerId = ReceiptSessionJsonObj._printerId;
+        return new ReceiptSession(state, receiptCategory, receiptType, receipt, lineNumber, printerRequired, printingFailed, printerId, receiptRequiredData);
+    }
+    static create() {
+        logger.traceEntry("create");
+        return new ReceiptSession(ReceiptState.Inactive);
+    }
+    get type() {
+        return this._type;
+    }
+    get state() {
+        return this._state;
+    }
+    get receiptCategory() {
+        return this._receiptCategory;
+    }
+    get receiptType() {
+        return this._receiptType;
+    }
+    get printerRequired() {
+        return this._printerRequired;
+    }
+    get receipt() {
+        return this._receipt;
+    }
+    get lineNumbers() {
+        return this._lineNumbers;
+    }
+    get receiptRequiredData() {
+        return this._receiptRequiredData;
+    }
+    get printingFailed() {
+        return this._printingFailed;
+    }
+    get printerId() {
+        return this._printerId;
+    }
+    get stateValues() {
+        logger.traceEntry("get stateValues");
+        return new Map([
+            ["ReceiptSession.state", this._state],
+            ["ReceiptSession.receiptCategory", this._receiptCategory],
+            ["ReceiptSession.receiptType", this._receiptType],
+            ["ReceiptSession.receipt", this._receipt],
+            ["ReceiptSession.printerRequired", this._printerRequired],
+            ["ReceiptSession.printingFailed", this._printingFailed],
+            ["ReceiptSession.waitingForReceiptForLineNumbers", this.inWaitingForReceiptForLineNumbers],
+            ["ReceiptSession.printerId", this._printerId],
+        ]);
+    }
+    get inWaitingForOptions() {
+        return this._state === ReceiptState.WaitingForOptions;
+    }
+    get inWaitingForReceipt() {
+        return this._state === ReceiptState.WaitingForReceipt;
+    }
+    get inWaitingForReceiptForLineNumbers() {
+        var _a;
+        return this._state === ReceiptState.WaitingForOptions && ((_a = this._receiptRequiredData) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    }
+    get inWaitingForPrinting() {
+        return this._state === ReceiptState.WaitingForPrinting;
+    }
+    get completed() {
+        return this._state === ReceiptState.Completed;
+    }
+    get isInactive() {
+        return this._state === ReceiptState.Inactive;
+    }
+    collectReceiptOptions(receiptCategory, printerRequired, receiptRequiredLineNumber) {
+        logger.traceEntry("collectReceiptOptions");
+        const receiptRequiredData = this._receiptRequiredData || [];
+        if (receiptRequiredLineNumber && receiptCategory) {
+            receiptRequiredData.push({ lineNumber: receiptRequiredLineNumber, receiptCategory });
+        }
+        return new ReceiptSession(ReceiptState.WaitingForOptions, receiptCategory, undefined, undefined, undefined, printerRequired, undefined, undefined, receiptRequiredData);
+    }
+    generate(receiptType) {
+        logger.traceEntry("generate");
+        return this.inWaitingForReceipt
+            ? this
+            : new ReceiptSession(ReceiptState.WaitingForReceipt, this._receiptCategory, receiptType);
+    }
+    printStarted(receipt, lineNumber) {
+        logger.traceEntry("printStarted");
+        if (this.inWaitingForPrinting) {
+            this._lineNumbers.push(lineNumber);
+            return this;
+        }
+        else {
+            return new ReceiptSession(ReceiptState.WaitingForPrinting, this._receiptCategory, this._receiptType, receipt || this._receipt, [lineNumber]);
+        }
+    }
+    stop(printingFailed, printerId) {
+        logger.traceEntry("stop");
+        return this.completed
+            ? this
+            : new ReceiptSession(ReceiptState.Completed, this._receiptCategory, this._receiptType, this._receipt, this._lineNumbers, undefined, printingFailed, printerId);
+    }
+    reset() {
+        return this.isInactive ? this : new ReceiptSession(ReceiptState.Inactive);
+    }
+}
+exports.ReceiptSession = ReceiptSession;
+const TRANSACTION_CLOSING_STATE_MAP = new Map([
+    [scp_types_commerce_transaction_1.MerchandiseTransactionClosingState.Suspended, ReceiptCategory.Suspend],
+]);
+function mapTransactionClosingState(closingState) {
+    return TRANSACTION_CLOSING_STATE_MAP.get(closingState);
+}
+function getReceiptCategoryFromLastTransaction(lastTransaction) {
+    return mapTransactionClosingState(lastTransaction && lastTransaction.closingState);
+}
+exports.getReceiptCategoryFromLastTransaction = getReceiptCategoryFromLastTransaction;
+//# sourceMappingURL=ReceiptSession.js.map

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

@@ -0,0 +1,49 @@
+import { DeviceIdentity, ITransaction, ITransactionLineFactory, IUser } from "@aptos-scp/scp-component-store-selling-core";
+import { IFiscalSignature } from "@aptos-scp/scp-types-commerce-transaction";
+import { IFiscalTransactionNumberMaintainer } from "./IFiscalTransactionNumberMaintainer";
+import { RetailTransaction } from "./RetailTransaction";
+import { IInvoiceOperation } from "./IInvoiceOperation";
+import { Customer } from "./Customer";
+export declare const REPRINT_RECEIPT_TRANSACTION_TYPE = "ReprintReceiptTransaction";
+export declare class ReprintReceiptTransaction extends RetailTransaction implements IInvoiceOperation, IFiscalTransactionNumberMaintainer {
+    private _invoiceNumber?;
+    private _invoiceSequenceNumber?;
+    private _invoiceSequenceNumberGenerator?;
+    private _fiscalSignature;
+    private _fiscalTransactionNumber;
+    private _fiscalTypeCode;
+    private _fiscalTransactionSequenceNumber;
+    private _fiscalTransactionSequenceNumberGenerator;
+    private _customer?;
+    private _invoiceFiscalTransactionNumber?;
+    private _invoiceTransactionNumber?;
+    private _accountingCurrency?;
+    static createFromJsonObj(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): ReprintReceiptTransaction;
+    constructor(deviceIdentity: DeviceIdentity, businessDayDate: string, transactionNumber: number, user?: IUser, transactionId?: string, invoiceNumber?: string, invoiceSequenceNumber?: number, invoiceSequenceNumberGenerator?: string, fiscalSignature?: IFiscalSignature, customer?: Customer, accountingCurrency?: string);
+    clone(): ITransaction;
+    get transactionStateValues(): Readonly<Map<string, any>>;
+    get invoiceNumber(): string;
+    get invoiceSequenceNumber(): number;
+    get invoiceSequenceNumberGenerator(): string;
+    get fiscalSignature(): IFiscalSignature;
+    get fiscalTransactionNumber(): string;
+    get fiscalTypeCode(): string;
+    get fiscalTransactionSequenceNumber(): number;
+    get fiscalTransactionSequenceNumberGenerator(): string;
+    get customer(): Customer;
+    get accountingCurrency(): string;
+    get invoiceFiscalTransactionNumber(): string;
+    get invoiceTransactionNumber(): number;
+    assignInvoiceNumber(invoiceNumber: string): ITransaction;
+    assignFiscalSignature(signatureData: IFiscalSignature): ITransaction;
+    assignInvoiceSequenceNumber(invoiceSequenceNumber: number, invoiceSequenceNumberGenerator: string): ITransaction;
+    assignFiscalTransactionNumber(fiscalTransactionNumber: string): ITransaction;
+    assignFiscalTypeCode(fiscalTypeCode: string): ITransaction;
+    assignFiscalTransactionSequenceNumber(fiscalTransactionSequenceNumber: number, fiscalTransactionSequenceNumberGenerator: string): ITransaction;
+    assignCustomer(customer: Customer): ITransaction;
+    assignAccountingCurrency(accountingCurrency: string): ITransaction;
+    assignInvoiceFiscalTransactionNumber(invoiceTransactionNumber: number, invoiceFiscalTransactionNumber: string): ITransaction;
+    protected newTransaction(): RetailTransaction;
+    protected loadFromJsonObject(transactionJsonObj: any, transactionLineFactory: ITransactionLineFactory): void;
+}
+export declare const isReprintReceiptTransaction: (transaction: ITransaction) => transaction is ReprintReceiptTransaction;

package/lib/domain/model/ReprintReceiptTransaction.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const ErrorCodes_1 = require("../../config/ErrorCodes");
+const RetailTransaction_1 = require("./RetailTransaction");
+const Customer_1 = require("./Customer");
+exports.REPRINT_RECEIPT_TRANSACTION_TYPE = "ReprintReceiptTransaction";
+class ReprintReceiptTransaction extends RetailTransaction_1.RetailTransaction {
+    constructor(deviceIdentity, businessDayDate, transactionNumber, user, transactionId, invoiceNumber, invoiceSequenceNumber, invoiceSequenceNumberGenerator, fiscalSignature, customer, accountingCurrency) {
+        super(deviceIdentity, businessDayDate, transactionNumber, exports.REPRINT_RECEIPT_TRANSACTION_TYPE, user, transactionId);
+        this._invoiceNumber = invoiceNumber;
+        this._invoiceSequenceNumber = invoiceSequenceNumber;
+        this._invoiceSequenceNumberGenerator = invoiceSequenceNumberGenerator;
+        this._fiscalSignature = fiscalSignature;
+        this._customer = customer;
+        this._accountingCurrency = accountingCurrency;
+    }
+    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 invoiceNumber = transactionJsonObj._invoiceNumber;
+        const invoiceSequenceNumber = transactionJsonObj._invoiceSequenceNumber;
+        const invoiceSequenceNumberGenerator = transactionJsonObj._invoiceSequenceNumberGenerator;
+        const fiscalSignature = transactionJsonObj._fiscalSignature;
+        const fiscalTransactionNumber = transactionJsonObj._fiscalTransactionNumber;
+        const fiscalTypeCode = transactionJsonObj._fiscalTypeCode;
+        const fiscalTransactionSequenceNumber = transactionJsonObj._fiscalTransactionSequenceNumber;
+        const fiscalTransactionSequenceNumberGenerator = transactionJsonObj._fiscalTransactionSequenceNumberGenerator;
+        const customer = Customer_1.Customer.createFromJsonObject(transactionJsonObj._customer);
+        const invoiceFiscalTransactionNumber = transactionJsonObj._invoiceFiscalTransactionNumber;
+        const invoiceTransactionNumber = transactionJsonObj._invoiceTransactionNumber;
+        const accountingCurrency = transactionJsonObj._accountingCurrency;
+        const receiptReprintTransaction = new ReprintReceiptTransaction(deviceIdentity, businessDayDate, transactionNumber, performingUser, transactionId, invoiceNumber, invoiceSequenceNumber, invoiceSequenceNumberGenerator, fiscalSignature);
+        receiptReprintTransaction.assignFiscalTransactionNumber(fiscalTransactionNumber);
+        receiptReprintTransaction.assignFiscalTypeCode(fiscalTypeCode);
+        receiptReprintTransaction.assignFiscalTransactionSequenceNumber(fiscalTransactionSequenceNumber, fiscalTransactionSequenceNumberGenerator);
+        receiptReprintTransaction.assignCustomer(customer);
+        receiptReprintTransaction.assignAccountingCurrency(accountingCurrency);
+        receiptReprintTransaction.assignInvoiceFiscalTransactionNumber(invoiceTransactionNumber, invoiceFiscalTransactionNumber);
+        receiptReprintTransaction.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        return receiptReprintTransaction;
+    }
+    clone() {
+        const transaction = super.clone();
+        if (exports.isReprintReceiptTransaction(transaction)) {
+            transaction._invoiceNumber = this._invoiceNumber;
+            transaction._invoiceSequenceNumber = this._invoiceSequenceNumber;
+            transaction._invoiceSequenceNumberGenerator = this._invoiceSequenceNumberGenerator;
+            transaction._fiscalSignature = this._fiscalSignature;
+            transaction._fiscalTransactionNumber = this._fiscalTransactionNumber;
+            transaction._fiscalTypeCode = this._fiscalTypeCode;
+            transaction._fiscalTransactionSequenceNumber = this._fiscalTransactionSequenceNumber;
+            transaction._fiscalTransactionSequenceNumberGenerator = this._fiscalTransactionSequenceNumberGenerator;
+            transaction._customer = this._customer;
+            transaction._invoiceFiscalTransactionNumber = this._invoiceFiscalTransactionNumber;
+            transaction._invoiceTransactionNumber = this._invoiceTransactionNumber;
+            transaction._accountingCurrency = this._accountingCurrency;
+        }
+        else {
+            throw new scp_component_store_selling_core_1.PosError("Cannot clone ReprintReceiptTransaction, " +
+                "because new instance is not a ReprintReceiptTransaction.", ErrorCodes_1.SSF_TRANSACTION_ERROR_CODE);
+        }
+        return transaction;
+    }
+    get transactionStateValues() {
+        return super.transactionStateValues;
+    }
+    get invoiceNumber() {
+        return this._invoiceNumber;
+    }
+    get invoiceSequenceNumber() {
+        return this._invoiceSequenceNumber;
+    }
+    get invoiceSequenceNumberGenerator() {
+        return this._invoiceSequenceNumberGenerator;
+    }
+    get fiscalSignature() {
+        return this._fiscalSignature;
+    }
+    get fiscalTransactionNumber() {
+        return this._fiscalTransactionNumber;
+    }
+    get fiscalTypeCode() {
+        return this._fiscalTypeCode;
+    }
+    get fiscalTransactionSequenceNumber() {
+        return this._fiscalTransactionSequenceNumber;
+    }
+    get fiscalTransactionSequenceNumberGenerator() {
+        return this._fiscalTransactionSequenceNumberGenerator;
+    }
+    get customer() {
+        return this._customer;
+    }
+    get accountingCurrency() {
+        return this._accountingCurrency;
+    }
+    get invoiceFiscalTransactionNumber() {
+        return this._invoiceFiscalTransactionNumber;
+    }
+    get invoiceTransactionNumber() {
+        return this._invoiceTransactionNumber;
+    }
+    assignInvoiceNumber(invoiceNumber) {
+        const newTransaction = this.clone();
+        newTransaction._invoiceNumber = invoiceNumber;
+        return newTransaction;
+    }
+    assignFiscalSignature(signatureData) {
+        const newTransaction = this.clone();
+        newTransaction._fiscalSignature = signatureData;
+        return newTransaction;
+    }
+    assignInvoiceSequenceNumber(invoiceSequenceNumber, invoiceSequenceNumberGenerator) {
+        const newTransaction = this.clone();
+        newTransaction._invoiceSequenceNumber = invoiceSequenceNumber;
+        newTransaction._invoiceSequenceNumberGenerator = invoiceSequenceNumberGenerator;
+        return newTransaction;
+    }
+    assignFiscalTransactionNumber(fiscalTransactionNumber) {
+        const newTransaction = this.clone();
+        newTransaction._fiscalTransactionNumber = fiscalTransactionNumber;
+        return newTransaction;
+    }
+    assignFiscalTypeCode(fiscalTypeCode) {
+        const newTransaction = this.clone();
+        newTransaction._fiscalTypeCode = fiscalTypeCode;
+        return newTransaction;
+    }
+    assignFiscalTransactionSequenceNumber(fiscalTransactionSequenceNumber, fiscalTransactionSequenceNumberGenerator) {
+        const newTransaction = this.clone();
+        newTransaction._fiscalTransactionSequenceNumber = fiscalTransactionSequenceNumber;
+        newTransaction._fiscalTransactionSequenceNumberGenerator = fiscalTransactionSequenceNumberGenerator;
+        return newTransaction;
+    }
+    assignCustomer(customer) {
+        const newTransaction = this.clone();
+        newTransaction._customer = customer;
+        return newTransaction;
+    }
+    assignAccountingCurrency(accountingCurrency) {
+        const newTransaction = this.clone();
+        newTransaction._accountingCurrency = accountingCurrency;
+        return newTransaction;
+    }
+    assignInvoiceFiscalTransactionNumber(invoiceTransactionNumber, invoiceFiscalTransactionNumber) {
+        const newTransaction = this.clone();
+        newTransaction._invoiceFiscalTransactionNumber = invoiceFiscalTransactionNumber;
+        newTransaction._invoiceTransactionNumber = invoiceTransactionNumber;
+        return newTransaction;
+    }
+    newTransaction() {
+        return new ReprintReceiptTransaction(this.deviceIdentity, this.businessDayDate, this.transactionNumber, this.performingUser, this.transactionId, this.invoiceNumber, this.invoiceSequenceNumber, this.invoiceSequenceNumberGenerator, this.fiscalSignature);
+    }
+    loadFromJsonObject(transactionJsonObj, transactionLineFactory) {
+        super.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        this._invoiceNumber = transactionJsonObj._invoiceNumber;
+        this._invoiceSequenceNumber = transactionJsonObj._invoiceSequenceNumber;
+        this._invoiceSequenceNumberGenerator = transactionJsonObj._invoiceSequenceNumberGenerator;
+        this._fiscalTransactionNumber = transactionJsonObj._fiscalTransactionNumber;
+        this._fiscalTypeCode = transactionJsonObj._fiscalTypeCode;
+        this._fiscalTransactionSequenceNumber = transactionJsonObj._fiscalTransactionSequenceNumber;
+        this._fiscalTransactionSequenceNumberGenerator =
+            transactionJsonObj._fiscalTransactionSequenceNumberGenerator;
+        this._customer = Customer_1.Customer.createFromJsonObject(transactionJsonObj._customer);
+        this._invoiceFiscalTransactionNumber = transactionJsonObj._invoiceFiscalTransactionNumber;
+        this._invoiceTransactionNumber = transactionJsonObj._invoiceTransactionNumber;
+        this._accountingCurrency = transactionJsonObj._accountingCurrency;
+    }
+}
+exports.ReprintReceiptTransaction = ReprintReceiptTransaction;
+exports.isReprintReceiptTransaction = (transaction) => {
+    return (transaction instanceof ReprintReceiptTransaction ||
+        transaction.transactionType === exports.REPRINT_RECEIPT_TRANSACTION_TYPE);
+};
+//# sourceMappingURL=ReprintReceiptTransaction.js.map

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

@@ -0,0 +1,22 @@
+import { IState } from "@aptos-scp/scp-component-store-selling-core";
+export declare const RESUME_SESSION: string;
+export declare enum ResumeTransactionSessionState {
+    WaitingForResume = "WaitingForResume",
+    WaitingForPostVoid = "WaitingForPostVoid",
+    Completed = "Completed"
+}
+export declare class ResumeTransactionSession implements IState {
+    private readonly _type;
+    private readonly _state;
+    static createFromJsonObject(resumeSessionJsonObj: any): ResumeTransactionSession;
+    static create(): ResumeTransactionSession;
+    get type(): string;
+    get isResuming(): boolean;
+    get isPostVoiding(): boolean;
+    get isCompleted(): boolean;
+    get stateValues(): Readonly<Map<string, any>>;
+    startResuming(): ResumeTransactionSession;
+    startPostVoiding(): ResumeTransactionSession;
+    complete(): ResumeTransactionSession;
+    private constructor();
+}

package/lib/domain/model/ResumeTransactionSession.js

@@ -0,0 +1,56 @@
+"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.ResumeTransactionSession");
+exports.RESUME_SESSION = "ResumeTransactionSession";
+var ResumeTransactionSessionState;
+(function (ResumeTransactionSessionState) {
+    ResumeTransactionSessionState["WaitingForResume"] = "WaitingForResume";
+    ResumeTransactionSessionState["WaitingForPostVoid"] = "WaitingForPostVoid";
+    ResumeTransactionSessionState["Completed"] = "Completed";
+})(ResumeTransactionSessionState = exports.ResumeTransactionSessionState || (exports.ResumeTransactionSessionState = {}));
+class ResumeTransactionSession {
+    constructor(state) {
+        this._type = exports.RESUME_SESSION;
+        this._state = state;
+    }
+    static createFromJsonObject(resumeSessionJsonObj) {
+        logger.traceEntry("createFromJsonObject");
+        const state = resumeSessionJsonObj._state;
+        return new ResumeTransactionSession(state);
+    }
+    static create() {
+        logger.traceEntry("create");
+        return new ResumeTransactionSession(ResumeTransactionSessionState.Completed);
+    }
+    get type() {
+        return this._type;
+    }
+    get isResuming() {
+        return this._state === ResumeTransactionSessionState.WaitingForResume;
+    }
+    get isPostVoiding() {
+        return this._state === ResumeTransactionSessionState.WaitingForPostVoid;
+    }
+    get isCompleted() {
+        return this._state === ResumeTransactionSessionState.Completed;
+    }
+    get stateValues() {
+        logger.traceEntry("get stateValues");
+        return new Map([
+            ["ResumeSession.state", this._state],
+            ["ResumeSession.isPostVoiding", this.isPostVoiding],
+        ]);
+    }
+    startResuming() {
+        return new ResumeTransactionSession(ResumeTransactionSessionState.WaitingForResume);
+    }
+    startPostVoiding() {
+        return new ResumeTransactionSession(ResumeTransactionSessionState.WaitingForPostVoid);
+    }
+    complete() {
+        return new ResumeTransactionSession(ResumeTransactionSessionState.Completed);
+    }
+}
+exports.ResumeTransactionSession = ResumeTransactionSession;
+//# sourceMappingURL=ResumeTransactionSession.js.map