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

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

@@ -0,0 +1,22 @@
+import { CouponStatus, ICouponAuthorizationServiceResult, RequestType } from "@aptos-scp/scp-types-commerce-transaction";
+export interface ISingleUseCouponRequest {
+    retailLocationId: string;
+    deviceId: string;
+    transactionNumber: number;
+    transactionId: string;
+    businessDayDate: string;
+    customerKey?: string;
+    couponCode: string;
+    correlationId: string;
+    allowExpiredTobeClaimed?: boolean;
+}
+export interface ISingleUseCouponResponse {
+    code: string;
+    promotionCouponCode: string;
+    couponUseType?: string;
+    claimRequired?: boolean;
+    status: CouponStatus;
+    claimedStatus: boolean;
+    expiryDate: string;
+}
+export declare function getCouponAuthorizationServiceResult(success: boolean, requestType: RequestType, response?: ISingleUseCouponResponse, error?: Error): ICouponAuthorizationServiceResult;

package/lib/domain/model/ISingleUseCoupon.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const scp_types_commerce_transaction_1 = require("@aptos-scp/scp-types-commerce-transaction");
+const utility_1 = require("../utility");
+function getCouponAuthorizationServiceResult(success, requestType, response, error) {
+    var _a, _b;
+    if (success && response) {
+        return {
+            successful: true,
+            couponUseType: response.couponUseType,
+            claimRequired: response.claimRequired,
+            status: response.status,
+            claimedStatus: response.claimedStatus,
+            expiryDate: response.expiryDate ? response.expiryDate : undefined,
+            requestType,
+        };
+    }
+    else {
+        return {
+            successful: false,
+            couponUseType: (_a = response) === null || _a === void 0 ? void 0 : _a.couponUseType,
+            claimRequired: (_b = response) === null || _b === void 0 ? void 0 : _b.claimRequired,
+            status: response ? response.status : undefined,
+            claimedStatus: response ? response.claimedStatus : undefined,
+            expiryDate: response && response.expiryDate ? response.expiryDate : undefined,
+            requestType,
+            failureReason: error instanceof scp_component_store_selling_core_1.PosError
+                ? utility_1.isTimeOutError(error)
+                    ? scp_types_commerce_transaction_1.FailureReasonEnum.Timeout
+                    : scp_types_commerce_transaction_1.FailureReasonEnum.ServiceError
+                : scp_types_commerce_transaction_1.FailureReasonEnum.ServiceError,
+            failureMessage: error.message,
+        };
+    }
+}
+exports.getCouponAuthorizationServiceResult = getCouponAuthorizationServiceResult;
+//# sourceMappingURL=ISingleUseCoupon.js.map

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

@@ -0,0 +1,12 @@
+import { IPricingMetadataPersistanceObject, ISerializedPriceCalculationResults } from "@aptos-scp/scp-component-pricing";
+import { IStoreItemMetadataPersistanceObject } from "@aptos-scp/scp-component-store-items";
+import { ITaxationMetadataPersistanceObject } from "@aptos-scp/scp-component-taxation";
+export interface ITransactionMetadataPersistanceObject {
+    itemData: IStoreItemMetadataPersistanceObject;
+    pricingData: IPricingMetadataPersistanceObject;
+    taxData: ITaxationMetadataPersistanceObject;
+    lastLookupSource: string;
+    previousLookupSource?: string;
+    isPricingOffline: boolean;
+    pricingLastResult: ISerializedPriceCalculationResults;
+}

package/lib/domain/model/ITransactionMetadataPersistanceObject.js

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

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

@@ -0,0 +1,156 @@
+import { IConfigurationManager, IConfigurationValues } from "@aptos-scp/scp-component-store-selling-core";
+import { FulfillmentType } from "@aptos-scp/scp-types-commerce-transaction";
+import { ItemFilterBy } from "@aptos-scp/scp-types-inventory";
+import { ItemLookupKey, StoreItem } from "./StoreItem";
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface IInventory {
+    itemKey?: string;
+    itemKeyType?: string;
+    retailLocationId?: string;
+    deliveryMethods: IDeliveryResponse[];
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface IDeliveryResponse {
+    fulfillmentType?: FulfillmentType;
+    businessUnit: IBusinessUnit;
+    quantities: IQuantityResponse;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface IQuantityResponse {
+    quantityType: QuantityType;
+    amount: number;
+    unit: string;
+    count: number;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface IItemFilterBy {
+    filterName: string;
+    filterMapping: IFilterMapping;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface IFilterMapping {
+    source: string;
+    identifier: string;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface IBusinessUnit {
+    businessUnitId: string;
+    typeCode: string;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface ICalculationProfile {
+    profileName: Profile;
+    customProfileName: string;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface ILocationRequest {
+    businessUnit: IBusinessUnit;
+    quantityType: QuantityType;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface INetworkRequest {
+    quantityType: QuantityType;
+    fulfillmentType: FulfillmentType;
+    calculationProfile: ICalculationProfile;
+    businessUnit?: IBusinessUnit;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface IInventoryRequest {
+    itemLookupKey: ItemLookupKey;
+    itemFilterBy: IItemFilterBy;
+    locationRequest: ILocationRequest;
+    networkRequests: INetworkRequest[];
+    offset?: number;
+    limit?: number;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export interface IInventoryResponse {
+    inventory: IInventory;
+    delayInMs?: number;
+    responseStatus?: number;
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export declare enum Profile {
+    sellingLocation = "sellingLocation",
+    deliveryProfile = "deliveryProfile",
+    customProfile = "customProfile"
+}
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+export declare enum QuantityType {
+    available = "available",
+    availableTotalOnHand = "availableTotalOnHand",
+    availableSafetyStock = "availableSafetyStock",
+    availableReserved = "availableReserved",
+    availableExternalReserved = "availableExternalReserved",
+    inTransit = "inTransit",
+    inTransitReserved = "inTransitReserved",
+    layawayReserved = "layawayReserved"
+}
+export declare function getItemFilterBy(item: StoreItem, configurationManager: IConfigurationManager): ItemFilterBy[];
+export declare function getItemFilterByValue(storeItem: StoreItem, filterBy: any): string;
+export declare function getItemLookupKey(defaultLookupKey: ItemLookupKey, omniChannelConfig: IConfigurationValues, selectedStoreItem: StoreItem): ItemLookupKey;

package/lib/domain/model/Inventory.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+var Profile;
+(function (Profile) {
+    Profile["sellingLocation"] = "sellingLocation";
+    Profile["deliveryProfile"] = "deliveryProfile";
+    Profile["customProfile"] = "customProfile";
+})(Profile = exports.Profile || (exports.Profile = {}));
+/**
+ * @deprecated
+ *
+ * This type is no longer supported. If you are looking to use a type related to the inventory api,
+ * please see the @aptos-scp/scp-types-inventory repo.
+ */
+var QuantityType;
+(function (QuantityType) {
+    QuantityType["available"] = "available";
+    QuantityType["availableTotalOnHand"] = "availableTotalOnHand";
+    QuantityType["availableSafetyStock"] = "availableSafetyStock";
+    QuantityType["availableReserved"] = "availableReserved";
+    QuantityType["availableExternalReserved"] = "availableExternalReserved";
+    QuantityType["inTransit"] = "inTransit";
+    QuantityType["inTransitReserved"] = "inTransitReserved";
+    QuantityType["layawayReserved"] = "layawayReserved";
+})(QuantityType = exports.QuantityType || (exports.QuantityType = {}));
+function getItemFilterBy(item, configurationManager) {
+    const itemFilterBy = [];
+    const storeOmniChannel = configurationManager.getStoreOmniChannelValues();
+    if (storeOmniChannel && storeOmniChannel.itemFilterBy && storeOmniChannel.itemFilterBy.length > 0) {
+        const configItemFilterBy = storeOmniChannel.itemFilterBy;
+        const filterByValue = getItemFilterByValue(item, configItemFilterBy[0]);
+        if (filterByValue) {
+            itemFilterBy.push({
+                name: configItemFilterBy[0].filterName,
+                value: filterByValue,
+            });
+        }
+    }
+    return itemFilterBy;
+}
+exports.getItemFilterBy = getItemFilterBy;
+function getItemFilterByValue(storeItem, filterBy) {
+    if (storeItem && storeItem.merchandiseHierarchy) {
+        const merchHierarchy = storeItem.merchandiseHierarchy;
+        const index = _.findIndex(merchHierarchy, (x) => x.nodeId.levelId.localeCompare(filterBy.filterMapping.identifier, undefined, {
+            sensitivity: "base",
+        }) === 0);
+        return index >= 0 ? merchHierarchy[index].nodeId.nodeIdInLevel : undefined;
+    }
+    else {
+        return undefined;
+    }
+}
+exports.getItemFilterByValue = getItemFilterByValue;
+function getItemLookupKey(defaultLookupKey, omniChannelConfig, selectedStoreItem) {
+    var _a, _b, _c;
+    let itemLookupKey = defaultLookupKey;
+    if (!defaultLookupKey) {
+        if (omniChannelConfig && omniChannelConfig.inventory && omniChannelConfig.inventory.itemKeyType) {
+            itemLookupKey = (_b = (_a = selectedStoreItem) === null || _a === void 0 ? void 0 : _a.itemLookupKeys) === null || _b === void 0 ? void 0 : _b.find((itemKey) => {
+                return itemKey.type === omniChannelConfig.inventory.itemKeyType;
+            });
+        }
+    }
+    if (!itemLookupKey) {
+        return (_c = selectedStoreItem) === null || _c === void 0 ? void 0 : _c.itemLookupKeys[0];
+    }
+    return itemLookupKey;
+}
+exports.getItemLookupKey = getItemLookupKey;
+//# sourceMappingURL=Inventory.js.map

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

@@ -0,0 +1,40 @@
+import { IState } from "@aptos-scp/scp-component-store-selling-core";
+import { TransactionWithAdditionalData } from "@aptos-scp/scp-types-ss-transaction-history";
+export declare const ITEM_HANDLING_SESSION: string;
+export declare class ItemHandlingSession implements IState {
+    private _returnWithTransaction;
+    private _state;
+    private _transactionInformationForReturn;
+    private _type;
+    private _itemAddedFromTransactionForReturn;
+    private _inputSource;
+    private _transactions;
+    private _offlineReturnTransaction;
+    private _cancelWithTransaction;
+    private _transactionInformationForCancel;
+    static create(): ItemHandlingSession;
+    static createFromJsonObject(transactionSessionJsonObject: any): ItemHandlingSession;
+    get isReturning(): boolean;
+    get returnWithTransaction(): boolean;
+    get cancelWithTransaction(): boolean;
+    get offlineReturnTransaction(): boolean;
+    get stateValues(): Readonly<Map<string, any>>;
+    get transactionInformationForReturn(): TransactionWithAdditionalData;
+    get transactionInformationForCancel(): TransactionWithAdditionalData;
+    get transactions(): TransactionWithAdditionalData[];
+    get type(): Readonly<string>;
+    get itemAddedFromTransactionForReturn(): boolean;
+    get inputSource(): string;
+    setItemAddedFromTransactionForReturn(itemAddedFromTransactionForReturn: boolean): ItemHandlingSession;
+    clearTransactions(): ItemHandlingSession;
+    reset(): ItemHandlingSession;
+    setReturnWithTransaction(isReturnWithTransaction: boolean): ItemHandlingSession;
+    setCancelWithTransaction(isCancelWithTransaction: boolean): ItemHandlingSession;
+    setOfflineReturnTransaction(isOfflineReturnTransaction: boolean): ItemHandlingSession;
+    setTransactionInformationForReturn(transaction?: TransactionWithAdditionalData, inputSource?: string): ItemHandlingSession;
+    setTransactionInformationForCancel(transaction?: TransactionWithAdditionalData, inputSource?: string): ItemHandlingSession;
+    selectTransactionInformationForReturn(transaction?: TransactionWithAdditionalData): ItemHandlingSession;
+    startReturning(): ItemHandlingSession;
+    stopReturning(): ItemHandlingSession;
+    private constructor();
+}

package/lib/domain/model/ItemHandlingSession.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ITEM_HANDLING_SESSION = "ItemHandlingSession";
+var ItemHandlingSessionState;
+(function (ItemHandlingSessionState) {
+    ItemHandlingSessionState["Selling"] = "Selling";
+    ItemHandlingSessionState["Returning"] = "Returning";
+})(ItemHandlingSessionState || (ItemHandlingSessionState = {}));
+class ItemHandlingSession {
+    constructor(state, returnWithTransaction, transactionInformationForReturn, itemsAddedToTransaction, inputSource, transactions, offlineReturnTransaction, cancelWithTransaction, transactionInformationForCancel) {
+        this._returnWithTransaction = returnWithTransaction;
+        this._state = state;
+        this._transactionInformationForReturn = transactionInformationForReturn;
+        this._type = exports.ITEM_HANDLING_SESSION;
+        this._itemAddedFromTransactionForReturn = itemsAddedToTransaction;
+        this._inputSource = inputSource;
+        this._transactions = transactions;
+        this._offlineReturnTransaction = offlineReturnTransaction;
+        this._cancelWithTransaction = cancelWithTransaction;
+        this._transactionInformationForCancel = transactionInformationForCancel;
+    }
+    static create() {
+        return new ItemHandlingSession(ItemHandlingSessionState.Selling, undefined, undefined, false, undefined, [], undefined, undefined, undefined);
+    }
+    static createFromJsonObject(transactionSessionJsonObject) {
+        return new ItemHandlingSession(transactionSessionJsonObject._state, transactionSessionJsonObject._returnWithTransaction, transactionSessionJsonObject._transactionInformationForReturn, transactionSessionJsonObject._itemAddedFromTransactionForReturn, transactionSessionJsonObject._inputSource, transactionSessionJsonObject._transactions, transactionSessionJsonObject._offlineReturnTransaction, transactionSessionJsonObject._cancelWithTransaction, transactionSessionJsonObject._transactionInformationForCancel);
+    }
+    get isReturning() {
+        return this._state === ItemHandlingSessionState.Returning;
+    }
+    get returnWithTransaction() {
+        return this._returnWithTransaction;
+    }
+    get cancelWithTransaction() {
+        return this._cancelWithTransaction;
+    }
+    get offlineReturnTransaction() {
+        return this._offlineReturnTransaction;
+    }
+    get stateValues() {
+        return new Map([
+            ["ItemHandlingSession.isReturning", this.isReturning],
+            ["ItemHandlingSession.returnWithTransaction", this.returnWithTransaction],
+            ["ItemHandlingSession.transactionInformationForReturn", this.transactionInformationForReturn],
+            ["ItemHandlingSession.itemAddedFromTransactionForReturn", this.itemAddedFromTransactionForReturn],
+            ["ItemHandlingSession.inputSource", this.inputSource],
+            ["ItemHandlingSession.transactions", this.transactions],
+            ["ItemHandlingSession.offlineReturnTransaction", this.offlineReturnTransaction],
+            ["ItemHandlingSession.cancelWithTransaction", this.cancelWithTransaction],
+            ["ItemHandlingSession.transactionInformationForCancel", this.transactionInformationForCancel],
+        ]);
+    }
+    get transactionInformationForReturn() {
+        return this._transactionInformationForReturn;
+    }
+    get transactionInformationForCancel() {
+        return this._transactionInformationForCancel;
+    }
+    get transactions() {
+        return this._transactions
+            ? this._transactions.map((transactionInformation) => transactionInformation.transactionWithAdditionalData)
+            : [];
+    }
+    get type() {
+        return this._type;
+    }
+    get itemAddedFromTransactionForReturn() {
+        return this._itemAddedFromTransactionForReturn;
+    }
+    get inputSource() {
+        return this._inputSource;
+    }
+    setItemAddedFromTransactionForReturn(itemAddedFromTransactionForReturn) {
+        return new ItemHandlingSession(this._state, this._returnWithTransaction, this._transactionInformationForReturn, itemAddedFromTransactionForReturn, this.inputSource, this._transactions, this._offlineReturnTransaction, this._cancelWithTransaction, this._transactionInformationForCancel);
+    }
+    clearTransactions() {
+        return new ItemHandlingSession(this._state, this._returnWithTransaction, this._transactionInformationForReturn, this._itemAddedFromTransactionForReturn, this._inputSource, [], this._offlineReturnTransaction, this._cancelWithTransaction, this._transactionInformationForCancel);
+    }
+    reset() {
+        return new ItemHandlingSession(ItemHandlingSessionState.Selling, undefined, undefined, false, undefined, [], undefined, undefined, undefined);
+    }
+    setReturnWithTransaction(isReturnWithTransaction) {
+        return new ItemHandlingSession(this._state, isReturnWithTransaction, isReturnWithTransaction ? this._transactionInformationForReturn : undefined, this._itemAddedFromTransactionForReturn, this._inputSource, this._transactions, this._offlineReturnTransaction, this._cancelWithTransaction, this._transactionInformationForCancel);
+    }
+    setCancelWithTransaction(isCancelWithTransaction) {
+        return new ItemHandlingSession(this._state, this._returnWithTransaction, this._transactionInformationForReturn, this._itemAddedFromTransactionForReturn, this._inputSource, this._transactions, this._offlineReturnTransaction, isCancelWithTransaction, isCancelWithTransaction ? this._transactionInformationForCancel : undefined);
+    }
+    setOfflineReturnTransaction(isOfflineReturnTransaction) {
+        return new ItemHandlingSession(this._state, this._returnWithTransaction, this._transactionInformationForReturn, this._itemAddedFromTransactionForReturn, this._inputSource, this._transactions, isOfflineReturnTransaction, this._cancelWithTransaction, this._transactionInformationForCancel);
+    }
+    setTransactionInformationForReturn(transaction, inputSource) {
+        const transactions = this._transactions || [];
+        if (transaction) {
+            if (this._returnWithTransaction &&
+                !transactions.find((transactionInformation) => transactionInformation.transactionWithAdditionalData.transactionId === transaction.transactionId)) {
+                transactions.push({
+                    transactionWithAdditionalData: transaction,
+                    inputSource,
+                });
+            }
+        }
+        return new ItemHandlingSession(this._state, this._returnWithTransaction, Object.assign({}, transaction), this._itemAddedFromTransactionForReturn, inputSource, transactions, this._offlineReturnTransaction, this._cancelWithTransaction, this._transactionInformationForCancel);
+    }
+    setTransactionInformationForCancel(transaction, inputSource) {
+        const transactions = this._transactions || [];
+        if (transaction) {
+            if (this._cancelWithTransaction &&
+                !transactions.find((transactionInformation) => transactionInformation.transactionWithAdditionalData.transactionId === transaction.transactionId)) {
+                transactions.push({
+                    transactionWithAdditionalData: transaction,
+                    inputSource,
+                });
+            }
+        }
+        return new ItemHandlingSession(this._state, this._returnWithTransaction, this._transactionInformationForReturn, this._itemAddedFromTransactionForReturn, inputSource, transactions, this._offlineReturnTransaction, this._cancelWithTransaction, Object.assign({}, transaction));
+    }
+    selectTransactionInformationForReturn(transaction) {
+        const selectedTransaction = this._transactions.find((transactionInformation) => transactionInformation.transactionWithAdditionalData.transactionId === transaction.transactionId);
+        return new ItemHandlingSession(this._state, this._returnWithTransaction, selectedTransaction
+            ? selectedTransaction.transactionWithAdditionalData
+            : this._transactionInformationForReturn, this._itemAddedFromTransactionForReturn, selectedTransaction ? selectedTransaction.inputSource : this._inputSource, this._transactions, this._offlineReturnTransaction, this._cancelWithTransaction, this._transactionInformationForCancel);
+    }
+    startReturning() {
+        return new ItemHandlingSession(ItemHandlingSessionState.Returning, this._returnWithTransaction, this._transactionInformationForReturn, this._itemAddedFromTransactionForReturn, this._inputSource, this._transactions, this._offlineReturnTransaction, this._cancelWithTransaction, this._transactionInformationForCancel);
+    }
+    stopReturning() {
+        return new ItemHandlingSession(ItemHandlingSessionState.Selling, this._returnWithTransaction, this._transactionInformationForReturn, this._itemAddedFromTransactionForReturn, this._inputSource, this._transactions, this._offlineReturnTransaction, this._cancelWithTransaction, this._transactionInformationForCancel);
+    }
+}
+exports.ItemHandlingSession = ItemHandlingSession;
+//# sourceMappingURL=ItemHandlingSession.js.map

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

@@ -0,0 +1,153 @@
+import { IMoney } from "@aptos-scp/scp-component-business-core";
+import { LoyaltyActivityType, LoyaltyRedemptionType } from "@aptos-scp/scp-types-commerce-transaction";
+import { CustomerMembership, LoyaltyEnrollmentRequest, LoyaltyPlan, LoyaltyRedemptionDetail, LoyaltyTransactionRequest, LoyaltyTransactionRequestLine, LoyaltyTransactionReversalRequest, MembershipStatus, MembershipType, RewardReason } from "@aptos-scp/scp-types-loyalty-memberships";
+export interface IStoreLoyaltyPlans {
+    defaultLoyaltyPlanKey: string;
+    retailLocationId: string;
+    createDate: Date;
+    loyaltyPlans: LoyaltyPlan[];
+}
+export interface ICustomerLoyaltyMembership extends CustomerMembership {
+    loyaltyPlan: LoyaltyPlan;
+    membershipType: MembershipType;
+    membershipStatus: MembershipStatus;
+    availablePointsForCurrentTransaction?: number;
+    isDefault?: boolean;
+}
+export interface LoyaltyPlanPoints {
+    loyaltyPlanKey: string;
+    availablePointBalance: number;
+}
+export declare enum LoyaltyTransactionType {
+    Adjustment = "Adjustment",
+    Redemption = "Redemption",
+    Sale = "Sale",
+    Reversal = "Reversal",
+    PendingSale = "PendingSale"
+}
+export declare enum LoyaltyRedemptionReversalStatus {
+    NotReversed = "NotReversed",
+    PartiallyReversed = "PartiallyReversed",
+    FullyReversed = "FullyReversed"
+}
+export declare enum LoyaltyRewardResult {
+    Coupon = "Coupon",
+    ImmediateDiscount = "ImmediateDiscount",
+    Certificate = "Certificate"
+}
+export interface ILoyaltyEnrollmentRequest {
+    data: LoyaltyEnrollmentRequest[];
+}
+export interface ILoyaltyActivityRequestLine extends LoyaltyTransactionRequestLine {
+}
+export interface ILoyaltyActivityRequest extends LoyaltyTransactionRequest {
+    lines?: ILoyaltyActivityRequestLine[];
+}
+export interface ILoyaltyMembershipActivity {
+    membership: ICustomerLoyaltyMembership;
+    /**
+     * The identifier assigned to the loyalty activity by the service during posting.
+     */
+    loyaltyActivityId?: string;
+    /**
+     * The type of loyalty Activity.
+     */
+    loyaltyActivityType: LoyaltyActivityType;
+    /**
+     * The number of regular points associated with the loyalty activity. This may be negative for returns,
+     * redemptions, and some adjustments.
+     */
+    regularPoints?: number;
+    /**
+     * The number of conditional points based on header-level conditions associated with the loyalty activity.  This
+     * includes conditional points based on store, date, total amounts, header coupons, membership types, etc.
+     */
+    headerConditionalPoints?: number;
+    /**
+     * The number of conditional points based on detail-level conditions associated with the loyalty activity.
+     */
+    detailConditionalPoints?: number;
+    /**
+     * The number of conditional points based on tender-level conditions associated with the loyalty activity.
+     */
+    tenderConditionalPoints?: number;
+    /**
+     * The total points posted for the activity. This includes regular points and conditional points.
+     */
+    pointsPosted: number;
+    /**
+     * The points on the loyalty activity that are available for redemption.
+     */
+    pointsAvailable: number;
+    /**
+     * The total redemption discount.
+     */
+    totalRedemptionDiscount?: IMoney;
+    /**
+     * The total redemption discount in central currency.
+     */
+    totalRedemptionDiscountCentral?: IMoney;
+    /**
+     * The reason type code associated with the loyalty activity.
+     */
+    reasonTypeCode?: string;
+    /**
+     * The certificate number generated by a redemption where the reason type had a result of certificate.
+     */
+    generatedCertificateNumber?: string;
+    /**
+     * The reward amount associated with the redemption.
+     */
+    redemptionAmount?: IMoney;
+    /**
+     * The reversal status associated with a redemption. If the plan configuration allows it, redemptions are
+     * automatically reversed (partialy or fully) if they are associated with a activity and some or all items from
+     * the original activities are returned.
+     */
+    redemptionReversalStatus?: LoyaltyRedemptionReversalStatus;
+    /**
+     * The client assigned identifier for matching requests to responses during posting operations.
+     */
+    requestId?: string;
+    /**
+     * Loyalty plan description falling back to loyalty plan name.
+     */
+    loyaltyPlanDescription: () => string;
+    /**
+     * Membership type description falling back to membership type name.
+     */
+    membershipTypeDescription: () => string;
+    /**
+     * The number of conditional points based on header-level, detail-level or tender-level conditions
+     * associated with the loyalty activity.
+     */
+    conditionalPoints?: number;
+    /**
+     * The total points posted for the transaction. This includes regular points and conditional points.
+     */
+    totalPoints: number;
+    /**
+     * The balance of points currently earned, either posted or not to the membership.
+     */
+    pointBalanceTotal: number;
+    /**
+     * The balance of points currently available for redemption.
+     */
+    pointBalanceAvailable: number;
+    /**
+     * The redemption details.
+     */
+    redemptionDetails?: LoyaltyRedemptionDetail[];
+}
+export interface ILoyaltyRewardReason extends RewardReason {
+    redemptionType?: LoyaltyRedemptionType;
+    rewardResult?: LoyaltyRewardResult;
+    requestId?: number;
+}
+export interface ILoyaltyReversalRequest extends LoyaltyTransactionReversalRequest {
+}
+export interface ILoyaltyMembershipResponse {
+    loyaltyActivities: ILoyaltyMembershipActivity[];
+    loyaltyBestAutoRedemptions?: ILoyaltyRewardReason[];
+    loyaltyAvailableRedemptions?: ILoyaltyRewardReason[];
+}

package/lib/domain/model/LoyaltyMembership.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var LoyaltyTransactionType;
+(function (LoyaltyTransactionType) {
+    LoyaltyTransactionType["Adjustment"] = "Adjustment";
+    LoyaltyTransactionType["Redemption"] = "Redemption";
+    LoyaltyTransactionType["Sale"] = "Sale";
+    LoyaltyTransactionType["Reversal"] = "Reversal";
+    LoyaltyTransactionType["PendingSale"] = "PendingSale";
+})(LoyaltyTransactionType = exports.LoyaltyTransactionType || (exports.LoyaltyTransactionType = {}));
+var LoyaltyRedemptionReversalStatus;
+(function (LoyaltyRedemptionReversalStatus) {
+    LoyaltyRedemptionReversalStatus["NotReversed"] = "NotReversed";
+    LoyaltyRedemptionReversalStatus["PartiallyReversed"] = "PartiallyReversed";
+    LoyaltyRedemptionReversalStatus["FullyReversed"] = "FullyReversed";
+})(LoyaltyRedemptionReversalStatus = exports.LoyaltyRedemptionReversalStatus || (exports.LoyaltyRedemptionReversalStatus = {}));
+var LoyaltyRewardResult;
+(function (LoyaltyRewardResult) {
+    LoyaltyRewardResult["Coupon"] = "Coupon";
+    LoyaltyRewardResult["ImmediateDiscount"] = "ImmediateDiscount";
+    LoyaltyRewardResult["Certificate"] = "Certificate";
+})(LoyaltyRewardResult = exports.LoyaltyRewardResult || (exports.LoyaltyRewardResult = {}));
+//# sourceMappingURL=LoyaltyMembership.js.map