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

package/lib/domain/model/Customer.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_types_commerce_transaction_1 = require("@aptos-scp/scp-types-commerce-transaction");
+//
+// Keys for use in relaying customers in collectedData (qualification) and nonContextualData (action).
+//
+//TODO:  Seems some of these keys are related to FEATURES, not this MODEL.  Where to better define them?
+//       Same pattern occurs in other model classes too.
+exports.CUSTOMER = "Customer"; // Value type: Customer
+exports.TAX_CUSTOMER = "TaxCustomer"; // Value type: TaxCustomer
+exports.CUSTOMER_LIST = "CustomerList"; // Value type: Customer[]
+exports.CUSTOMER_CREATE_PROPERTIES = "CustomerCreateProperties"; // Value type: ICreateUpdateCustomerProperties
+exports.CUSTOMER_CREATION_RESULT = "CustomerCreationResult"; // Value type: ICustomerCreationResult
+exports.CUSTOMER_UPDATE_RESULT = "CustomerUpdateResult"; // Value type: ICustomerUpdateResult
+exports.CUSTOMER_LOOKUP_RESULT = "CustomerLookupResult"; // Value type: ICustomerResult
+exports.CUSTOMER_DATE_FORMAT = "CustomerDateFormat";
+var TriggeredMessageType;
+(function (TriggeredMessageType) {
+    TriggeredMessageType["Data"] = "Data";
+    TriggeredMessageType["Information"] = "Information";
+    TriggeredMessageType["Action"] = "Action";
+    TriggeredMessageType["Warning"] = "Warning";
+})(TriggeredMessageType = exports.TriggeredMessageType || (exports.TriggeredMessageType = {}));
+var CustomerAttributes;
+(function (CustomerAttributes) {
+    CustomerAttributes["AddressTypes"] = "AddressTypes";
+    CustomerAttributes["Countries"] = "Countries";
+    CustomerAttributes["Genders"] = "Genders";
+    CustomerAttributes["Titles"] = "Titles";
+    CustomerAttributes["Languages"] = "Languages";
+    CustomerAttributes["MaritalStatus"] = "MaritalStatus";
+    CustomerAttributes["EmailTypes"] = "EmailTypes";
+    CustomerAttributes["PhoneTypes"] = "PhoneTypes";
+    CustomerAttributes["ValidationSettings"] = "ValidationSettings";
+})(CustomerAttributes = exports.CustomerAttributes || (exports.CustomerAttributes = {}));
+//
+// Customer class, implementing ICustomerProperties
+//
+class Customer {
+    static createFromICreateUpdateCustomerProperties(createCustomerProperties) {
+        let customer = undefined;
+        if (createCustomerProperties) {
+            customer = new Customer();
+            customer.firstName = createCustomerProperties.firstName;
+            customer.lastName = createCustomerProperties.lastName;
+            customer.suffix = createCustomerProperties.suffix;
+            customer.phoneCountryCode = createCustomerProperties.phoneCountryCode;
+            customer.phoneNumber = createCustomerProperties.phoneNumber;
+            customer.textOptIn = createCustomerProperties.textOptIn || scp_types_commerce_transaction_1.OptIn.Unknown;
+            customer.phoneOptIn = createCustomerProperties.phoneOptIn || scp_types_commerce_transaction_1.OptIn.Unknown;
+            customer.emailAddress = createCustomerProperties.emailAddress;
+            customer.emailOptIn = createCustomerProperties.emailOptIn || scp_types_commerce_transaction_1.OptIn.Unknown;
+            customer.address1 = createCustomerProperties.address1;
+            customer.address2 = createCustomerProperties.address2;
+            customer.address3 = createCustomerProperties.address3;
+            customer.address4 = createCustomerProperties.address4;
+            customer.city = createCustomerProperties.city;
+            customer.district = createCustomerProperties.district;
+            customer.state = createCustomerProperties.state;
+            customer.firstAdminDivision = createCustomerProperties.firstAdminDivision;
+            customer.secondAdminDivision = createCustomerProperties.secondAdminDivision;
+            customer.firstAdminDivisionType = createCustomerProperties.firstAdminDivisionType;
+            customer.secondAdminDivisionType = createCustomerProperties.secondAdminDivisionType;
+            customer.geoLocationCode = createCustomerProperties.geoLocationCode;
+            customer.thirdAdminDivision = createCustomerProperties.thirdAdminDivision;
+            customer.thirdAdminDivisionType = createCustomerProperties.thirdAdminDivisionType;
+            customer.firstAdminDivisionCode = createCustomerProperties.firstAdminDivisionCode;
+            customer.secondAdminDivisionCode = createCustomerProperties.secondAdminDivisionCode;
+            customer.thirdAdminDivisionCode = createCustomerProperties.thirdAdminDivisionCode;
+            customer.postalCode = createCustomerProperties.postalCode;
+            customer.countryCode = createCustomerProperties.countryCode;
+            customer.countryName = createCustomerProperties.countryName;
+            customer.mailOptIn = createCustomerProperties.mailOptIn || scp_types_commerce_transaction_1.OptIn.Unknown;
+            customer.companyName = createCustomerProperties.companyName;
+            customer.salutation = createCustomerProperties.salutation;
+            customer.titleCode = createCustomerProperties.titleCode;
+            customer.gender = createCustomerProperties.gender;
+            customer.birthDate = createCustomerProperties.birthDate;
+            customer.preferredLanguage = createCustomerProperties.preferredLanguage;
+            customer.createSource = createCustomerProperties.createSource;
+            customer.customerType = createCustomerProperties.customerType;
+            customer.loyaltyMemberships = createCustomerProperties.loyaltyMemberships;
+            customer.allowPromptForLoyaltyEnrollment = createCustomerProperties.allowPromptForLoyaltyEnrollment;
+            customer.earliestNextLoyaltyEnrollmentPromptDate =
+                createCustomerProperties.earliestNextLoyaltyEnrollmentPromptDate;
+            customer.emails = createCustomerProperties.emails;
+            customer.addresses = createCustomerProperties.addresses;
+            customer.phones = createCustomerProperties.phones;
+            customer.alternateKeys = createCustomerProperties.alternateKeys;
+        }
+        return customer;
+    }
+    static createFromIUpdateCustomerProperties(updateCustomerProperties) {
+        let customer = undefined;
+        if (updateCustomerProperties) {
+            customer = new Customer();
+            customer.customerNumber = updateCustomerProperties.customerNumber;
+            customer.alternativeCustomerNumber = updateCustomerProperties.alternativeCustomerNumber;
+            customer.firstName = updateCustomerProperties.firstName;
+            customer.lastName = updateCustomerProperties.lastName;
+            customer.suffix = updateCustomerProperties.suffix;
+            customer.phoneId = updateCustomerProperties.phoneId;
+            customer.phoneIndex = updateCustomerProperties.phoneIndex;
+            customer.phoneCountryCode = updateCustomerProperties.phoneCountryCode;
+            customer.phoneNumber = updateCustomerProperties.phoneNumber;
+            customer.textOptIn = updateCustomerProperties.textOptIn;
+            customer.phoneOptIn = updateCustomerProperties.phoneOptIn;
+            customer.emailId = updateCustomerProperties.emailId;
+            customer.emailIndex = updateCustomerProperties.emailIndex;
+            customer.emailAddress = updateCustomerProperties.emailAddress;
+            customer.emailOptIn = updateCustomerProperties.emailOptIn;
+            customer.addressId = updateCustomerProperties.addressId;
+            customer.addressIndex = updateCustomerProperties.addressIndex;
+            customer.address1 = updateCustomerProperties.address1;
+            customer.address2 = updateCustomerProperties.address2;
+            customer.address3 = updateCustomerProperties.address3;
+            customer.address4 = updateCustomerProperties.address4;
+            customer.city = updateCustomerProperties.city;
+            customer.district = updateCustomerProperties.district;
+            customer.state = updateCustomerProperties.state;
+            customer.firstAdminDivision = updateCustomerProperties.firstAdminDivision;
+            customer.secondAdminDivision = updateCustomerProperties.secondAdminDivision;
+            customer.firstAdminDivisionType = updateCustomerProperties.firstAdminDivisionType;
+            customer.secondAdminDivisionType = updateCustomerProperties.secondAdminDivisionType;
+            customer.geoLocationCode = updateCustomerProperties.geoLocationCode;
+            customer.thirdAdminDivision = updateCustomerProperties.thirdAdminDivision;
+            customer.thirdAdminDivisionType = updateCustomerProperties.thirdAdminDivisionType;
+            customer.firstAdminDivisionCode = updateCustomerProperties.firstAdminDivisionCode;
+            customer.secondAdminDivisionCode = updateCustomerProperties.secondAdminDivisionCode;
+            customer.thirdAdminDivisionCode = updateCustomerProperties.thirdAdminDivisionCode;
+            customer.postalCode = updateCustomerProperties.postalCode;
+            customer.countryCode = updateCustomerProperties.countryCode;
+            customer.countryName = updateCustomerProperties.countryName;
+            customer.mailOptIn = updateCustomerProperties.mailOptIn;
+            customer.companyName = updateCustomerProperties.companyName;
+            customer.salutation = updateCustomerProperties.salutation;
+            customer.titleCode = updateCustomerProperties.titleCode;
+            customer.gender = updateCustomerProperties.gender;
+            customer.birthDate = updateCustomerProperties.birthDate;
+            customer.preferredLanguage = updateCustomerProperties.preferredLanguage;
+            customer.customerType = updateCustomerProperties.customerType;
+            customer.loyaltyMemberships = updateCustomerProperties.loyaltyMemberships;
+            customer.allowPromptForLoyaltyEnrollment = updateCustomerProperties.allowPromptForLoyaltyEnrollment;
+            customer.earliestNextLoyaltyEnrollmentPromptDate =
+                updateCustomerProperties.earliestNextLoyaltyEnrollmentPromptDate;
+            customer.extensibilityData = updateCustomerProperties.extensibilityData;
+            customer.emails = updateCustomerProperties.emails;
+            customer.addresses = updateCustomerProperties.addresses;
+            customer.phones = updateCustomerProperties.phones;
+            customer.alternateKeys = updateCustomerProperties.alternateKeys;
+        }
+        return customer;
+    }
+    /**
+     * Construct a new Customer object to be used to exchange the information
+     * with the server.
+     *
+     * @param customerFromJson JSON representation of the customer.
+     */
+    static createFromJsonObject(customerFromJson) {
+        let customer = undefined;
+        if (customerFromJson) {
+            customer = new Customer();
+            customer.customerNumber = customerFromJson.customerNumber;
+            customer.alternativeCustomerNumber = customerFromJson.alternativeCustomerNumber;
+            customer.firstName = customerFromJson.firstName;
+            customer.lastName = customerFromJson.lastName;
+            customer.suffix = customerFromJson.suffix;
+            customer.phoneId = customerFromJson.phoneId;
+            customer.phoneIndex = customerFromJson.phoneIndex;
+            customer.phoneCountryCode = customerFromJson.phoneCountryCode;
+            customer.phoneNumber = customerFromJson.phoneNumber;
+            customer.textOptIn = customerFromJson.textOptIn;
+            customer.phoneOptIn = customerFromJson.phoneOptIn;
+            customer.emailId = customerFromJson.emailId;
+            customer.emailIndex = customerFromJson.emailIndex;
+            customer.emailAddress = customerFromJson.emailAddress;
+            customer.emailOptIn = customerFromJson.emailOptIn;
+            customer.addressId = customerFromJson.addressId;
+            customer.addressIndex = customerFromJson.addressIndex;
+            customer.address1 = customerFromJson.address1;
+            customer.address2 = customerFromJson.address2;
+            customer.address3 = customerFromJson.address3;
+            customer.address4 = customerFromJson.address4;
+            customer.city = customerFromJson.city;
+            customer.district = customerFromJson.district;
+            customer.state = customerFromJson.state;
+            customer.firstAdminDivision = customerFromJson.firstAdminDivision;
+            customer.secondAdminDivision = customerFromJson.secondAdminDivision;
+            customer.firstAdminDivisionType = customerFromJson.firstAdminDivisionType;
+            customer.secondAdminDivisionType = customerFromJson.secondAdminDivisionType;
+            customer.geoLocationCode = customerFromJson.geoLocationCode;
+            customer.thirdAdminDivision = customerFromJson.thirdAdminDivision;
+            customer.thirdAdminDivisionType = customerFromJson.thirdAdminDivisionType;
+            customer.firstAdminDivisionCode = customerFromJson.firstAdminDivisionCode;
+            customer.secondAdminDivisionCode = customerFromJson.secondAdminDivisionCode;
+            customer.thirdAdminDivisionCode = customerFromJson.thirdAdminDivisionCode;
+            customer.postalCode = customerFromJson.postalCode;
+            customer.countryCode = customerFromJson.countryCode;
+            customer.countryName = customerFromJson.countryName || undefined;
+            customer.mailOptIn = customerFromJson.mailOptIn;
+            customer.companyName = customerFromJson.companyName;
+            customer.salutation = customerFromJson.salutation;
+            customer.titleCode = customerFromJson.titleCode || undefined;
+            customer.headOfHouseholdFlag = customerFromJson.headOfHouseholdFlag;
+            customer.gender = customerFromJson.gender;
+            customer.birthDate = customerFromJson.birthDate ? new Date(customerFromJson.birthDate) : undefined;
+            customer.preferredLanguage = customerFromJson.preferredLanguage;
+            customer.customerType = customerFromJson.customerType;
+            customer.loyaltyMembershipLookupIndicator = customerFromJson.loyaltyMembershipLookupIndicator;
+            customer.hasLoyaltyMemberships = customerFromJson.hasLoyaltyMemberships;
+            customer.loyaltyMemberships = customerFromJson.loyaltyMemberships;
+            customer.availableLoyaltyPlans = customerFromJson.availableLoyaltyPlans;
+            customer.allowPromptForLoyaltyEnrollment = customerFromJson.allowPromptForLoyaltyEnrollment;
+            customer.earliestNextLoyaltyEnrollmentPromptDate =
+                customerFromJson.earliestNextLoyaltyEnrollmentPromptDate;
+            customer.attributes = customerFromJson.attributes;
+            customer.extensibilityData = customerFromJson.extensibilityData;
+            customer.tags = customerFromJson.tags;
+            customer.emails = customerFromJson.emails;
+            customer.addresses = customerFromJson.addresses;
+            customer.phones = customerFromJson.phones;
+            customer.alternateKeys = customerFromJson.alternateKeys;
+            customer.triggeredMessages = customerFromJson.triggeredMessages;
+        }
+        return customer;
+    }
+    get fullName() {
+        return Customer.formatFullName(this);
+    }
+    static formatFullName(customer) {
+        let formattedName = "";
+        if (customer) {
+            formattedName = formattedName + (customer.salutation ? customer.salutation.trim() + " " : "");
+            formattedName = formattedName + (customer.firstName ? customer.firstName.trim() + " " : "");
+            formattedName = formattedName + (customer.lastName ? customer.lastName.trim() + " " : "");
+            formattedName = formattedName + (customer.suffix ? customer.suffix.trim() + " " : "");
+            formattedName = formattedName.trim();
+        }
+        return formattedName;
+    }
+    updateAvailablePlans(storeLoyaltyPlans) {
+        var _a;
+        //filter out already joined plans and make sure default plan is first.
+        this.availableLoyaltyPlans =
+            storeLoyaltyPlans && ((_a = storeLoyaltyPlans.loyaltyPlans
+                .filter((plan) => {
+                return (!(this.loyaltyMemberships &&
+                    this.loyaltyMemberships.find((custMembership) => custMembership.loyaltyPlanKey === plan.loyaltyPlanKey)) &&
+                    plan.membershipTypes &&
+                    plan.membershipTypes.find((memType) => memType.assignAtPos));
+            })) === null || _a === void 0 ? void 0 : _a.sort((l1, l2) => (l1.loyaltyPlanKey === storeLoyaltyPlans.defaultLoyaltyPlanKey ? -1 : 1)));
+    }
+}
+exports.Customer = Customer;
+class TaxCustomer extends Customer {
+}
+exports.TaxCustomer = TaxCustomer;
+function convertLoyaltyMembership(source) {
+    return {
+        loyaltyPlan: source.loyaltyPlan && {
+            loyaltyPlanKey: source.loyaltyPlan.loyaltyPlanKey,
+            name: source.loyaltyPlan.description || source.loyaltyPlan.name,
+            accumulatePoints: source.loyaltyPlan.accumulatePoints,
+        },
+        membershipType: source.membershipType && {
+            membershipTypeKey: source.membershipTypeKey,
+            name: source.membershipType.description || source.membershipType.name,
+            level: source.membershipType.level,
+            posPromotionCustomerLevel: source.membershipType.posPromotionCustomerLevel,
+            discountPercentage: source.membershipType.discountPercentage,
+        },
+        membershipStatus: source.membershipStatus && {
+            membershipStatusKey: source.membershipStatus.membershipStatusKey,
+            isActiveStatus: source.membershipStatus.isActiveStatus,
+        },
+        availablePointBalance: source.availablePointBalance,
+        pendingPointBalance: source.pendingPointBalance,
+        postedPointBalance: source.postedPointBalance,
+    };
+}
+exports.convertLoyaltyMembership = convertLoyaltyMembership;
+function convertAttribute(source) {
+    return {
+        id: source.id,
+        groupCode: source.groupCode,
+        dataElements: source.dataElements.map(convertDataElement),
+        createdAt: source.createdAt,
+        createdBy: source.createdBy,
+        createdAtRetailLocation: source.createdAtRetailLocation,
+        updatedAt: source.updatedAt,
+        updatedBy: source.updatedBy,
+        updatedAtRetailLocation: source.updatedAtRetailLocation,
+        updatedBySource: source.updatedBySource,
+    };
+}
+exports.convertAttribute = convertAttribute;
+function convertDataElement(source) {
+    return {
+        key: source.key,
+        value: source.value,
+    };
+}
+function convertTag(source) {
+    return {
+        tagKey: source.tagKey,
+        rank: source.rank,
+        label: source.label,
+        description: source.description,
+        connotation: source.connotation,
+        forecolor: source.forecolor,
+        backcolor: source.backcolor,
+        imageUri: source.imageUri,
+        value: source.value,
+        language: source.language,
+        translations: source.translations,
+    };
+}
+exports.convertTag = convertTag;
+//# sourceMappingURL=Customer.js.map

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

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

package/lib/domain/model/CustomerServiceTransaction.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RetailTransaction_1 = require("./RetailTransaction");
+exports.CUSTOMER_TRANSACTION_TYPE = "CustomerServiceTransaction";
+class CustomerServiceTransaction 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 customerServiceTransaction = new CustomerServiceTransaction(deviceIdentity, businessDayDate, transactionNumber, performingUser, transactionId);
+        customerServiceTransaction.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+        return customerServiceTransaction;
+    }
+    constructor(deviceIdentity, businessDayDate, transactionNumber, user, transactionId) {
+        super(deviceIdentity, businessDayDate, transactionNumber, exports.CUSTOMER_TRANSACTION_TYPE, user, transactionId);
+    }
+    clone() {
+        const transaction = super.clone();
+        return transaction;
+    }
+    get transactionStateValues() {
+        return new Map([...super.transactionStateValues.entries()]);
+    }
+    newTransaction() {
+        return new CustomerServiceTransaction(this.deviceIdentity, this.businessDayDate, this.transactionNumber, this.performingUser, this.transactionId);
+    }
+    loadFromJsonObject(transactionJsonObj, transactionLineFactory) {
+        super.loadFromJsonObject(transactionJsonObj, transactionLineFactory);
+    }
+}
+exports.CustomerServiceTransaction = CustomerServiceTransaction;
+exports.isCustomerServiceTransaction = (transaction) => {
+    return (transaction &&
+        (transaction instanceof CustomerServiceTransaction ||
+            transaction.transactionType === exports.CUSTOMER_TRANSACTION_TYPE));
+};
+//# sourceMappingURL=CustomerServiceTransaction.js.map

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

@@ -0,0 +1,15 @@
+export interface IDepartment {
+    id: string;
+    name: string;
+    description: string;
+    departmentId: string;
+    departmentGroupId: string;
+    taxGroupId: string;
+    language: string;
+    translations?: {
+        [language: string]: {
+            name: string;
+            description: string;
+        };
+    };
+}

package/lib/domain/model/Department.js

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

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

@@ -0,0 +1,24 @@
+export declare enum EmailStatus {
+    Valid = "Valid",
+    Invalid = "Invalid",
+    InvalidWithBypass = "InvalidWithBypass"
+}
+export interface IEmailVerification {
+    emailAddress?: string;
+}
+export declare const EMAILVERIFICATION = "EmailVerification";
+export declare const VERIFIED_DATA_LIST = "VERIFIED_DATA_LIST";
+export declare class EmailVerification implements IEmailVerification {
+    private _emailAddress;
+    private _emailStatus;
+    static createFromJsonObject(emailFromJson: any): EmailVerification;
+    /**
+     * Construct email verify status object to be used to exchange the verification message with the server.
+     *
+     * @param emailAddress The email address.
+     * @param emailStatus The email verify status
+     */
+    constructor(emailAddress: string);
+    get emailAddress(): string;
+    get emailStatus(): EmailStatus;
+}

package/lib/domain/model/EmailVerification.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var EmailStatus;
+(function (EmailStatus) {
+    EmailStatus["Valid"] = "Valid";
+    EmailStatus["Invalid"] = "Invalid";
+    EmailStatus["InvalidWithBypass"] = "InvalidWithBypass";
+})(EmailStatus = exports.EmailStatus || (exports.EmailStatus = {}));
+exports.EMAILVERIFICATION = "EmailVerification";
+exports.VERIFIED_DATA_LIST = "VERIFIED_DATA_LIST";
+class EmailVerification {
+    /**
+     * Construct email verify status object to be used to exchange the verification message with the server.
+     *
+     * @param emailAddress The email address.
+     * @param emailStatus The email verify status
+     */
+    constructor(emailAddress) {
+        this._emailAddress = emailAddress;
+    }
+    static createFromJsonObject(emailFromJson) {
+        if (!emailFromJson) {
+            return undefined;
+        }
+        return new EmailVerification(emailFromJson._emailAddress);
+    }
+    get emailAddress() {
+        return this._emailAddress;
+    }
+    get emailStatus() {
+        return this._emailStatus;
+    }
+}
+exports.EmailVerification = EmailVerification;
+//# sourceMappingURL=EmailVerification.js.map

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

@@ -0,0 +1,80 @@
+export declare enum AccountStatus {
+    Active = "Active",
+    Inactive = "Inactive",
+    Deleted = "Deleted",
+    Locked = "Locked"
+}
+export interface IEmployee {
+    /**
+     * The unique ID for the employee in the system
+     */
+    employeeNumber: string;
+    /**
+     * The number on the employee's ID. This might be different than the employee number
+     */
+    employeeIdNumber?: string;
+    /**
+     * The employee's first name
+     */
+    firstName: string;
+    /**
+     * The employee's middle name
+     */
+    middleName?: string;
+    /**
+     * The employee's last name
+     */
+    lastName: string;
+    /**
+     * The name of the employee as shown on the display.
+     */
+    displayName: string;
+    /**
+     * The status of the employee account.
+     */
+    accountStatus: AccountStatus;
+    /**
+     * The username of the User associated with the Employee, if available.
+     */
+    associatedUsername?: string;
+    /**
+     * The value if the employee is registered as the cashier.
+     */
+    isDefault?: boolean;
+}
+export declare class Employee implements IEmployee {
+    private _employeeNumber;
+    private _employeeIdNumber?;
+    private _firstName?;
+    private _middleName?;
+    private _lastName?;
+    private _displayName?;
+    private _accountStatus;
+    private _associatedUsername?;
+    private _isDefault?;
+    static createFromIEmployee(employee: IEmployee): Employee;
+    static createFromJsonObject(employeeFromJson: any): Employee;
+    /**
+     * Construct a new employee object to be used to exchange the information with the server.
+     *
+     * @param employeeNumber The employee number.
+     * @param firstName The employee's first name
+     * @param lastName The employee's last name
+     * @param employeeIdNumber The number on the employee's ID.
+     * @param middleName The employee's middle name
+     * @param displayName The display name
+     * @param accountStatus The account status
+     * @param associatedUsername The username of the User associated with the Employee
+     * @param isDefault The value if the employee is the cashier
+     */
+    constructor(employeeNumber: string, firstName?: string, lastName?: string, employeeIdNumber?: string, middleName?: string, displayName?: string, accountStatus?: AccountStatus, associatedUsername?: string, isDefault?: boolean);
+    get employeeNumber(): string;
+    get employeeIdNumber(): string;
+    get firstName(): string;
+    get middleName(): string;
+    get lastName(): string;
+    get displayName(): string;
+    get accountStatus(): AccountStatus;
+    get associatedUsername(): string;
+    get isDefault(): boolean;
+}

package/lib/domain/model/Employee.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AccountStatus;
+(function (AccountStatus) {
+    AccountStatus["Active"] = "Active";
+    AccountStatus["Inactive"] = "Inactive";
+    AccountStatus["Deleted"] = "Deleted";
+    AccountStatus["Locked"] = "Locked";
+})(AccountStatus = exports.AccountStatus || (exports.AccountStatus = {}));
+class Employee {
+    /**
+     * Construct a new employee object to be used to exchange the information with the server.
+     *
+     * @param employeeNumber The employee number.
+     * @param firstName The employee's first name
+     * @param lastName The employee's last name
+     * @param employeeIdNumber The number on the employee's ID.
+     * @param middleName The employee's middle name
+     * @param displayName The display name
+     * @param accountStatus The account status
+     * @param associatedUsername The username of the User associated with the Employee
+     * @param isDefault The value if the employee is the cashier
+     */
+    constructor(employeeNumber, firstName, lastName, employeeIdNumber, middleName, displayName, accountStatus, associatedUsername, isDefault) {
+        this._employeeNumber = employeeNumber;
+        this._firstName = firstName;
+        this._lastName = lastName;
+        this._employeeIdNumber = employeeIdNumber;
+        this._middleName = middleName;
+        this._displayName = displayName;
+        this._accountStatus = accountStatus;
+        this._associatedUsername = associatedUsername;
+        this._isDefault = isDefault;
+    }
+    static createFromIEmployee(employee) {
+        return new Employee(employee.employeeNumber, employee.firstName, employee.lastName, employee.employeeIdNumber, employee.middleName, employee.displayName, employee.accountStatus, employee.associatedUsername, employee.isDefault);
+    }
+    static createFromJsonObject(employeeFromJson) {
+        if (!employeeFromJson) {
+            return undefined;
+        }
+        return new Employee(employeeFromJson._employeeNumber, employeeFromJson._firstName, employeeFromJson._lastName, employeeFromJson._employeeIdNumber, employeeFromJson._middleName, employeeFromJson._displayName, employeeFromJson._accountStatus, employeeFromJson._associatedUsername, employeeFromJson._isDefault);
+    }
+    get employeeNumber() {
+        return this._employeeNumber;
+    }
+    get employeeIdNumber() {
+        return this._employeeIdNumber;
+    }
+    get firstName() {
+        return this._firstName;
+    }
+    get middleName() {
+        return this._middleName;
+    }
+    get lastName() {
+        return this._lastName;
+    }
+    get displayName() {
+        return this._displayName;
+    }
+    get accountStatus() {
+        return this._accountStatus;
+    }
+    get associatedUsername() {
+        return this._associatedUsername;
+    }
+    get isDefault() {
+        return this._isDefault;
+    }
+}
+exports.Employee = Employee;
+//# sourceMappingURL=Employee.js.map

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

@@ -0,0 +1,39 @@
+import { IState, UiInput } from "@aptos-scp/scp-component-store-selling-core";
+import { TenderType } from "./TenderType";
+export declare const END_OF_TRANSACTION_TENDERING_SESSION: string;
+export declare enum EndOfTransactionTenderingSessionState {
+    Open = "Open",
+    ChangeInProgress = "ChangeInProgress",
+    ChangeFallbackInProgress = "ChangeFallbackInProgress"
+}
+export interface IChangeFallbackOptions {
+    allowVoid: boolean;
+    isVoidFailure: boolean;
+    fallbackTenders?: TenderType[];
+    failedChangeTenderType?: TenderType;
+}
+export interface IChangeInputOptions {
+    requiredChangeInputs: string[];
+    inputs: UiInput[];
+    validChangeTenderTypes: TenderType[];
+}
+export declare class EndOfTransactionTenderingSession implements IState {
+    private _state;
+    private _changeFallbackOptions;
+    private _changeInputOptions;
+    private _type;
+    static create(): EndOfTransactionTenderingSession;
+    static createFromJsonObject(endOfTransactionTenderingSessionJsonObject: any): EndOfTransactionTenderingSession;
+    get isChangeInProgress(): boolean;
+    get isChangeFallbackInProgress(): boolean;
+    get isOpen(): boolean;
+    get changeInputOptions(): IChangeInputOptions;
+    get changeFallbackOptions(): IChangeFallbackOptions;
+    get changeRequiresInputs(): boolean;
+    get stateValues(): Readonly<Map<string, any>>;
+    get type(): Readonly<string>;
+    waitForChange(changeInputOptions?: IChangeInputOptions): EndOfTransactionTenderingSession;
+    waitForChangeFallback(fallbackOptions?: IChangeFallbackOptions, changeInputOptions?: IChangeInputOptions): EndOfTransactionTenderingSession;
+    changeComplete(): EndOfTransactionTenderingSession;
+    private constructor();
+}