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

package/lib/domain/model/configuration/DataEntryRule.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scp_component_logging_1 = require("@aptos-scp/scp-component-logging");
+const scp_component_store_selling_core_1 = require("@aptos-scp/scp-component-store-selling-core");
+const IDataEntryRuleConfig_1 = require("./IDataEntryRuleConfig");
+const logger = scp_component_logging_1.LogManager.getLogger("com.aptos.storeselling.domain.model.configuration.DataEntryRule");
+class DataEntryRule {
+    constructor(configuredRule) {
+        if (!configuredRule) {
+            throw new Error("configuredRule must be provided");
+        }
+        this.configuredRule = configuredRule;
+        this.originalDataEntry = undefined;
+        this.originalDataInputSource = undefined;
+        this.originalDataEntryOptions = undefined;
+        this.regexMatches = undefined;
+    }
+    satisfiesMatchingConditions(enteredData, inputSource, options) {
+        const entryMethod = logger.traceEntry("satisfiesMatchingConditions");
+        this.originalDataEntry = enteredData;
+        this.originalDataInputSource = inputSource;
+        this.originalDataEntryOptions = options;
+        this.regexMatches = undefined; // Reset any prior regexMatches
+        const satisfactionResult = this.satisfiesInputSourceConditions(inputSource, options) &&
+            this.satisfiesDataPatternConditions(enteredData);
+        return logger.traceExit(entryMethod, satisfactionResult);
+    }
+    transformDataEntry() {
+        const entryMethod = logger.traceEntry("transformDataEntry");
+        logger.debug(`transformDataEntry acting on original data: [${this.originalDataEntry}] ` +
+            `having regexMatches: [${JSON.stringify(this.regexMatches)}] ` +
+            `with configured transformations: [${JSON.stringify(this.configuredRule.submitUiBusinessEvent.uiInputs)}]`);
+        const transformedUiInputs = this.configuredRule.submitUiBusinessEvent.uiInputs.map((anInput) => {
+            let transformedInput = undefined;
+            if (anInput) {
+                transformedInput = new scp_component_store_selling_core_1.UiInput(anInput.inputKey, this.applyInputTransformations(this.originalDataEntry, anInput.inputValueTransformations), "string", this.originalDataInputSource, this.originalDataEntryOptions && this.originalDataEntryOptions.encoding
+                    ? this.originalDataEntryOptions.encoding
+                    : undefined);
+            }
+            return transformedInput;
+        });
+        const transformationResult = {
+            eventType: this.configuredRule.submitUiBusinessEvent.eventType,
+            inputData: transformedUiInputs,
+        };
+        logger.debug(`transformDataEntry result: [${JSON.stringify(transformationResult)}]`);
+        return logger.traceExit(entryMethod, transformationResult);
+    }
+    satisfiesInputSourceConditions(inputSource, options) {
+        const entryMethod = logger.traceEntry("satisfiesInputSourceConditions");
+        let satisfactionResult = false;
+        if (this.configuredRule.matchingConditions.inputSourceConditions.length === 0) {
+            // There are no conditions, therefore the rule matches
+            satisfactionResult = true;
+        }
+        else {
+            satisfactionResult = this.configuredRule.matchingConditions.inputSourceConditions.reduce((alreadySatisfied, anInputConditionConfiguration) => {
+                return (alreadySatisfied ||
+                    (this.satisfiesInputSource(inputSource, anInputConditionConfiguration) &&
+                        this.satisfiesInputSourceOptions(options, anInputConditionConfiguration)));
+            }, false);
+        }
+        return logger.traceExit(entryMethod, satisfactionResult);
+    }
+    satisfiesInputSource(inputSource, anInputCondition) {
+        const entryMethod = logger.traceEntry("satisfiesInputSource");
+        const satisfactionResult = (anInputCondition.inputSource !== inputSource && !anInputCondition.isEqual) ||
+            (anInputCondition.inputSource === inputSource && anInputCondition.isEqual);
+        return logger.traceExit(entryMethod, satisfactionResult);
+    }
+    satisfiesInputSourceOptions(options, anInputCondition) {
+        const entryMethod = logger.traceEntry("satisfiesInputSourceOptions");
+        let satisfactionResult = true;
+        if (anInputCondition.options) {
+            const anInputConditionOptionKeys = Object.keys(anInputCondition.options);
+            for (const inputConditionOptionKey of anInputConditionOptionKeys) {
+                let conditionSatisfactionResult = false;
+                if (inputConditionOptionKey.endsWith("NotEmpty")) {
+                    const inputConditionOptionValue = anInputCondition.options[inputConditionOptionKey];
+                    const optionName = inputConditionOptionKey.substring(0, inputConditionOptionKey.length - "NotEmpty".length);
+                    conditionSatisfactionResult = this.satisfiesInputSourceOptionNotEmpty(inputConditionOptionValue, optionName, options);
+                }
+                else {
+                    const inputConditionOptionValue = anInputCondition.options[inputConditionOptionKey];
+                    if (inputConditionOptionKey.endsWith("NotOneOf")) {
+                        const optionName = inputConditionOptionKey.substring(0, inputConditionOptionKey.length - "NotOneOf".length);
+                        conditionSatisfactionResult = this.satisfiesInputSourceOptionNotOneOf(inputConditionOptionValue, optionName, options);
+                    }
+                    else {
+                        if (inputConditionOptionKey.endsWith("OneOf")) {
+                            const optionName = inputConditionOptionKey.substring(0, inputConditionOptionKey.length - "OneOf".length);
+                            conditionSatisfactionResult = this.satisfiesInputSourceOptionOneOf(inputConditionOptionValue, optionName, options);
+                        }
+                    }
+                }
+                satisfactionResult = satisfactionResult && conditionSatisfactionResult;
+            }
+        }
+        return logger.traceExit(entryMethod, satisfactionResult);
+    }
+    satisfiesInputSourceOptionNotEmpty(shouldBeNonEmpty, optionName, options) {
+        let conditionSatisfactionResult = false;
+        // The "NotEmpty" condition ensures that the submitted option value is empty or not empty.
+        // The condition is met if:
+        // - NotEmpty TRUE and
+        //   - There ARE options submitted and
+        //   - The named option exists and
+        //   - Its value is non-empty
+        // OR
+        // - NotEmpty FALSE and
+        //   - There ARE no options submitted or
+        //   - The named option does not exist or
+        //   - Its value is empty
+        if ((shouldBeNonEmpty &&
+            !!options &&
+            options.hasOwnProperty(optionName) &&
+            options[optionName] &&
+            options[optionName].length > 0) ||
+            (!shouldBeNonEmpty && (!options || !options.hasOwnProperty(optionName) || !options[optionName]))) {
+            conditionSatisfactionResult = true;
+        }
+        return conditionSatisfactionResult;
+    }
+    satisfiesInputSourceOptionNotOneOf(configuredList, optionName, options) {
+        let conditionSatisfactionResult = false;
+        // The "NotOneOf" condition ensures that the submitted option is NOT one of a set.
+        // The condition is met if:
+        // - There are NO OPTIONS submitted (it's not in the excluded set if it's not even submitted) or
+        // - The named option doesn't exist in the named set given or
+        // - The named option exists and its value is not in that set
+        if (!options ||
+            !options.hasOwnProperty(optionName) ||
+            (options.hasOwnProperty(optionName) && configuredList.indexOf(options[optionName]) < 0)) {
+            conditionSatisfactionResult = true;
+        }
+        return conditionSatisfactionResult;
+    }
+    satisfiesInputSourceOptionOneOf(configuredList, optionName, options) {
+        let conditionSatisfactionResult = false;
+        // The "OneOf" condition ensures that the submitted option is one of a set.
+        // The condition is met if:
+        // - There ARE options submitted and
+        // - The named option exists and
+        // - Its value is in that set
+        if (!!options && options.hasOwnProperty(optionName) && configuredList.indexOf(options[optionName]) >= 0) {
+            conditionSatisfactionResult = true;
+        }
+        return conditionSatisfactionResult;
+    }
+    satisfiesDataPatternConditions(enteredData) {
+        const entryMethod = logger.traceEntry("satisfiesDataPatternConditions");
+        let satisfactionResult = true;
+        if (this.configuredRule.matchingConditions.dataPatternConditions.length > 0) {
+            for (const anInputConditionConfiguration of this.configuredRule.matchingConditions
+                .dataPatternConditions) {
+                satisfactionResult =
+                    satisfactionResult &&
+                        this.satisfiesDataPatternCondition(enteredData, anInputConditionConfiguration);
+            }
+        }
+        return logger.traceExit(entryMethod, satisfactionResult);
+    }
+    satisfiesDataPatternCondition(enteredData, anInputCondition) {
+        const entryMethod = logger.traceEntry("satisfiesDataPatternCondition");
+        let satisfactionResult = false;
+        switch (anInputCondition.dataCondition) {
+            case IDataEntryRuleConfig_1.DataEntryRuleDataConditionNames.startsWith:
+                satisfactionResult = enteredData.startsWith(anInputCondition.prefix);
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleDataConditionNames.endsWith:
+                satisfactionResult = enteredData.endsWith(anInputCondition.suffix);
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleDataConditionNames.hasLength:
+                if (anInputCondition.hasOwnProperty("length")) {
+                    satisfactionResult = enteredData.length === anInputCondition.length;
+                }
+                else {
+                    satisfactionResult =
+                        enteredData.length >= anInputCondition.minLength &&
+                            enteredData.length <= anInputCondition.maxLength;
+                }
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleDataConditionNames.matchesRegex:
+                this.regexMatches = enteredData.match(new RegExp(anInputCondition.regex, anInputCondition.regexFlags));
+                satisfactionResult = !!this.regexMatches;
+                break;
+            default:
+                break;
+        }
+        return logger.traceExit(entryMethod, satisfactionResult);
+    }
+    applyInputTransformations(incomingValue, transformations) {
+        const entryMethod = logger.traceEntry("applyInputTransformations");
+        let resultValue = incomingValue;
+        if (transformations) {
+            for (const aTransformation of transformations) {
+                resultValue = this.applyInputTransformation(resultValue, aTransformation);
+            }
+        }
+        return logger.traceExit(entryMethod, resultValue);
+    }
+    applyInputTransformation(incomingValue, transformation) {
+        const entryMethod = logger.traceEntry("applyInputTransformations");
+        let resultValue = incomingValue;
+        switch (transformation.transformationType) {
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.useConstantValue:
+                resultValue = transformation.constantValue;
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.useSubstring:
+                if (resultValue) {
+                    resultValue = resultValue.substr(transformation.startIndex, transformation.length);
+                    resultValue = this.handleTrimLeftPadding(resultValue, transformation);
+                }
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.useRegexGroupIndex:
+                resultValue = this.regexMatches ? this.regexMatches[transformation.regexGroup] : undefined;
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.useSubmittedOption:
+                resultValue = this.originalDataEntryOptions
+                    ? this.originalDataEntryOptions[transformation.optionName]
+                    : undefined;
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.leftPadString:
+                if (!resultValue) {
+                    resultValue = "";
+                }
+                if (resultValue.length < transformation.length) {
+                    const padString = transformation.padCharacter.repeat(transformation.length);
+                    resultValue = (padString + resultValue).substr(transformation.length * -1);
+                }
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.rightPadString:
+                if (!resultValue) {
+                    resultValue = "";
+                }
+                if (resultValue.length < transformation.length) {
+                    const padString = transformation.padCharacter.repeat(transformation.length);
+                    resultValue = (resultValue + padString).substr(0, transformation.length);
+                }
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.prependString:
+                const prefix = this.generateStringToAppendPrepend(resultValue, transformation);
+                resultValue = prefix + (resultValue || "");
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.appendString:
+                const suffix = this.generateStringToAppendPrepend(resultValue, transformation);
+                resultValue = (resultValue || "") + suffix;
+                break;
+            case IDataEntryRuleConfig_1.DataEntryRuleTransformationNames.generateCheckDigit:
+                if (resultValue) {
+                    const checkDigit = this.generateCheckDigit(resultValue);
+                    resultValue = checkDigit;
+                }
+                break;
+            default:
+                break;
+        }
+        return logger.traceExit(entryMethod, resultValue);
+    }
+    generateStringToAppendPrepend(incomingValue, transformation) {
+        let result;
+        if (!Array.isArray(transformation.fragment)) {
+            result = transformation.fragment;
+        }
+        else {
+            result = this.applyInputTransformations(incomingValue, transformation.fragment);
+        }
+        return result;
+    }
+    /**
+     * Used to calculate check digit of the incoming value, assumes modulo 10 R31
+     */
+    generateCheckDigit(incomingValue) {
+        if (incomingValue.length % 2 === 1) {
+            incomingValue = `0${incomingValue}`;
+        }
+        const stringArray = incomingValue.split("");
+        const result = stringArray.reduce((prevVal, currVal, index) => {
+            let nextVal;
+            if (index % 2 === 0) {
+                nextVal = parseInt(prevVal, 10) + parseInt(currVal, 10);
+            }
+            else {
+                nextVal = parseInt(prevVal, 10) + parseInt(currVal, 10) * 3;
+            }
+            return nextVal.toString();
+        });
+        const resultNum = parseInt(result, 10);
+        const ceiling = Math.ceil(resultNum / 10) * 10;
+        return (ceiling - resultNum).toString(10);
+    }
+    handleTrimLeftPadding(incomingValue, transformation) {
+        if (transformation.trimLeftPadCharacter && transformation.trimLeftPadCharacter.length > 0) {
+            const regExp = new RegExp(`^${transformation.trimLeftPadCharacter}+`);
+            return incomingValue.replace(regExp, "");
+        }
+        else {
+            return incomingValue;
+        }
+    }
+}
+exports.DataEntryRule = DataEntryRule;
+//# sourceMappingURL=DataEntryRule.js.map

package/lib/domain/model/configuration/I18nReceiptFormattingInterface.d.ts

@@ -0,0 +1,38 @@
+import { MerchandiseTransactionTradeType } from "@aptos-scp/scp-types-commerce-transaction";
+import { ILabel } from "../Constants";
+import { IThresholdLimit } from "./IReceiptFormattingConfig";
+export interface IReceiptFormattingByType {
+    receiptCategory: IReceiptType;
+}
+export interface ITradeType {
+    headerLabel: string;
+}
+export interface IReceiptType {
+    formattingByTradeType: IFormattingByTradeType;
+}
+export interface IFormattingByTradeType {
+    tradeType: ITradeType;
+}
+export interface FooterLine {
+    printForCategory: string;
+    preLoaded?: boolean;
+    printForOriginalTransaction?: boolean;
+    printForPostVoid?: boolean;
+    printForTradeTypes?: Array<MerchandiseTransactionTradeType>;
+    messages: Array<ILabel>;
+}
+export interface HeaderLine {
+    printForCategory: string;
+    messages: Array<ILabel>;
+}
+export interface IRevenueStamp {
+    description?: string;
+    stampAmount: string;
+    stampImage: string;
+    stampImageLandscape: string;
+    transactionTotalThreshold: IThresholdLimit;
+}
+export interface IRevenueStampGroupMapping {
+    revenueStampGroupName: string;
+    revenueStamp: IRevenueStamp;
+}

package/lib/domain/model/configuration/I18nReceiptFormattingInterface.js

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

package/lib/domain/model/configuration/I18nTaxFreeConfig.d.ts

@@ -0,0 +1,11 @@
+export interface I18nTaxFreeConfig {
+    mixWithInvoiceAllowed?: boolean;
+    servicesEligible?: boolean;
+    includeItemsWithZeroVatRate?: boolean;
+    zeroVatRateCategoryMapping?: IZeroVatRateCategoryMapping[];
+    invoicing: any;
+}
+export interface IZeroVatRateCategoryMapping {
+    vatCode: string;
+    goodCategory: string;
+}

package/lib/domain/model/configuration/I18nTaxFreeConfig.js

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

package/lib/domain/model/configuration/IAccessPolicyConfig.d.ts

@@ -0,0 +1,5 @@
+export interface IAccessPolicyConfig {
+    minimumSecurityLevel: number;
+    supervisorOverrideAllowed: boolean;
+    deferApprovalUntilTotal: boolean;
+}

package/lib/domain/model/configuration/IAccessPolicyConfig.js

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

package/lib/domain/model/configuration/IAdapterPoliciesConfig.d.ts

@@ -0,0 +1,24 @@
+export declare enum AdapterPolicies {
+    localOnlyPolicy = "localOnly",
+    remoteOnlyPolicy = "remoteOnly",
+    localBeforeRemotePolicy = "localBeforeRemote",
+    remoteBeforeLocalPolicy = "remoteBeforeLocal",
+    localBeforeRemoteConsistencyPolicy = "localBeforeRemoteConsistency",
+    remoteBeforeLocalConsistencyPolicy = "remoteBeforeLocalConsistency",
+    remoteBeforeLocalLatchingPolicy = "remoteBeforeLocalLatching"
+}
+export interface IAdapterPoliciesConfig {
+    pricingAdapter: IPricingAdapters;
+    taxationAdapter: ITaxationAdapterPolicy;
+    storeItemAdapter: IStoreItemAdapterPolicy;
+}
+export interface ITaxationAdapterPolicy {
+    updateTaxationPolicy: AdapterPolicies;
+}
+export interface IStoreItemAdapterPolicy {
+    updateStoreItemPolicy: AdapterPolicies;
+}
+export interface IPricingAdapters {
+    updatePricingPolicy: AdapterPolicies;
+    productInquiryPricingPolicy: AdapterPolicies;
+}

package/lib/domain/model/configuration/IAdapterPoliciesConfig.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AdapterPolicies;
+(function (AdapterPolicies) {
+    AdapterPolicies["localOnlyPolicy"] = "localOnly";
+    AdapterPolicies["remoteOnlyPolicy"] = "remoteOnly";
+    AdapterPolicies["localBeforeRemotePolicy"] = "localBeforeRemote";
+    AdapterPolicies["remoteBeforeLocalPolicy"] = "remoteBeforeLocal";
+    AdapterPolicies["localBeforeRemoteConsistencyPolicy"] = "localBeforeRemoteConsistency";
+    AdapterPolicies["remoteBeforeLocalConsistencyPolicy"] = "remoteBeforeLocalConsistency";
+    AdapterPolicies["remoteBeforeLocalLatchingPolicy"] = "remoteBeforeLocalLatching";
+})(AdapterPolicies = exports.AdapterPolicies || (exports.AdapterPolicies = {}));
+//# sourceMappingURL=IAdapterPoliciesConfig.js.map

package/lib/domain/model/configuration/IConditionalAttributeBehaviorRuleConfig.d.ts

@@ -0,0 +1,32 @@
+export declare enum ConditionType {
+    AnyOf = "anyOf",
+    AllOf = "allOf"
+}
+export interface IConditionalAttributeBehaviorRuleConfig {
+    [ruleCode: string]: IConditionalAttributeBehaviorRuleDefinition;
+}
+export interface IConditionalAttributeBehaviorRuleDefinition {
+    conditions: IConditionalAttributeBehaviorRuleAttributeGroups;
+    conditionType: ConditionType;
+    results: IConditionalAttributeBehaviorRuleResult;
+}
+export interface IConditionalAttributeBehaviorRuleAttributeGroups {
+    [groupCode: string]: IConditionalAttributeBehaviorRuleDataElements;
+}
+export interface IConditionalAttributeBehaviorRuleDataElements {
+    [key: string]: IConditionalAttributeBehaviorRuleDataElementValue;
+}
+export interface IConditionalAttributeBehaviorRuleDataElementValue {
+    value: any;
+}
+export interface IConditionalAttributeBehaviorRuleResult {
+    submitResults: IConditionalAttributeBehaviorRuleSubmitResult;
+    attributeResults: IConditionalAttributeBehaviorRuleAttributeGroups;
+}
+export interface IConditionalAttributeBehaviorRuleSubmitResult {
+    disallowSaveCustomer: boolean;
+    errorText: {
+        i18nCode: string;
+        default: string;
+    };
+}

package/lib/domain/model/configuration/IConditionalAttributeBehaviorRuleConfig.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ConditionType;
+(function (ConditionType) {
+    ConditionType["AnyOf"] = "anyOf";
+    ConditionType["AllOf"] = "allOf";
+})(ConditionType = exports.ConditionType || (exports.ConditionType = {}));
+//# sourceMappingURL=IConditionalAttributeBehaviorRuleConfig.js.map

package/lib/domain/model/configuration/ICustomerConfig.d.ts

@@ -0,0 +1,31 @@
+export interface ICustomerConfig {
+    loyalty: ILoyaltyConfig;
+}
+export interface ILoyaltyConfig {
+    readonly enabled: boolean;
+    readonly realTimePoints: IRealTimePointConfig;
+    readonly applyPermanentMembershipDiscounts?: boolean;
+}
+export declare enum LoyaltyQualifyingTransactions {
+    None = "None",
+    MerchandiseWithRedemption = "MerchandiseWithRedemption",
+    AllMerchandise = "AllMerchandise"
+}
+export interface IDisplayBehavior {
+    readonly displayBalancesWithoutRealTimePointsEnabled: boolean;
+    readonly showAvailableBalance: boolean;
+    readonly showTotalBalance: boolean;
+    readonly showCurrentTransactionTotalPoints: boolean;
+    readonly showCurrentTransactionRegularPoints: boolean;
+    readonly showCurrentTransactionConditionalPoints: boolean;
+}
+export interface IRealTimePointConfig {
+    readonly qualifyingTransactions: LoyaltyQualifyingTransactions;
+    readonly preferredItemKeyType?: string[];
+    readonly minimumSpendThresholdIncludesReturns?: boolean;
+}
+export declare enum AssignCustomerFromOriginalSaleForReturns {
+    DoNotPromptOrAssign = "DoNotPromptOrAssign",
+    AssignWithPrompt = "AssignWithPrompt",
+    AssignWithoutPrompt = "AssignWithoutPrompt"
+}

package/lib/domain/model/configuration/ICustomerConfig.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var LoyaltyQualifyingTransactions;
+(function (LoyaltyQualifyingTransactions) {
+    LoyaltyQualifyingTransactions["None"] = "None";
+    LoyaltyQualifyingTransactions["MerchandiseWithRedemption"] = "MerchandiseWithRedemption";
+    LoyaltyQualifyingTransactions["AllMerchandise"] = "AllMerchandise";
+})(LoyaltyQualifyingTransactions = exports.LoyaltyQualifyingTransactions || (exports.LoyaltyQualifyingTransactions = {}));
+var AssignCustomerFromOriginalSaleForReturns;
+(function (AssignCustomerFromOriginalSaleForReturns) {
+    AssignCustomerFromOriginalSaleForReturns["DoNotPromptOrAssign"] = "DoNotPromptOrAssign";
+    AssignCustomerFromOriginalSaleForReturns["AssignWithPrompt"] = "AssignWithPrompt";
+    AssignCustomerFromOriginalSaleForReturns["AssignWithoutPrompt"] = "AssignWithoutPrompt";
+})(AssignCustomerFromOriginalSaleForReturns = exports.AssignCustomerFromOriginalSaleForReturns || (exports.AssignCustomerFromOriginalSaleForReturns = {}));
+//# sourceMappingURL=ICustomerConfig.js.map

package/lib/domain/model/configuration/IDataEntryRuleConfig.d.ts

@@ -0,0 +1,66 @@
+import { BarcodeEncoding } from "@aptos-scp/scp-types-commerce-devices";
+export interface IDataEntryOptions {
+    encoding?: BarcodeEncoding;
+    [option: string]: string;
+}
+export declare enum DataEntryRuleDataConditionNames {
+    startsWith = "startsWith",
+    endsWith = "endsWith",
+    hasLength = "hasLength",
+    matchesRegex = "matchesRegex"
+}
+export declare enum DataEntryRuleTransformationNames {
+    useConstantValue = "useConstantValue",
+    useSubstring = "useSubstring",
+    useRegexGroupIndex = "useRegexGroupIndex",
+    useSubmittedOption = "useSubmittedOption",
+    leftPadString = "leftPadString",
+    rightPadString = "rightPadString",
+    prependString = "prependString",
+    appendString = "appendString",
+    generateCheckDigit = "generateCheckDigit"
+}
+export interface IDataEntryRuleConfig {
+    descriptiveNotes?: string;
+    matchingConditions: IDataEntryRuleMatchingConditionConfig;
+    submitUiBusinessEvent: {
+        eventType: string;
+        uiInputs: IDataEntryRuleUiInputConfig[];
+    };
+}
+export interface IDataEntryRuleUiInputConfig {
+    inputKey: string;
+    inputValueTransformations?: IDataEntryRuleTransformationConfig[];
+}
+export interface IDataEntryRuleMatchingConditionConfig {
+    inputSourceConditions: IDataEntryRuleInputSourceConditionConfig[];
+    dataPatternConditions: IDataEntryRuleDataPatternConditionConfig[];
+}
+export interface IDataEntryRuleInputSourceConditionConfig {
+    inputSource: string;
+    isEqual: boolean;
+    options?: {
+        [notEmptyOroneOfOrNotOneOf: string]: string[] | boolean;
+    };
+}
+export interface IDataEntryRuleDataPatternConditionConfig {
+    dataCondition: DataEntryRuleDataConditionNames;
+    prefix?: string;
+    suffix?: string;
+    length?: number;
+    minLength?: number;
+    maxLength?: number;
+    regex?: string;
+    regexFlags?: string;
+}
+export interface IDataEntryRuleTransformationConfig {
+    transformationType: DataEntryRuleTransformationNames;
+    constantValue?: string;
+    startIndex?: number;
+    length?: number;
+    regexGroup?: number;
+    padCharacter?: string;
+    optionName?: string;
+    fragment?: string | IDataEntryRuleTransformationConfig[];
+    trimLeftPadCharacter?: string;
+}

package/lib/domain/model/configuration/IDataEntryRuleConfig.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var DataEntryRuleDataConditionNames;
+(function (DataEntryRuleDataConditionNames) {
+    DataEntryRuleDataConditionNames["startsWith"] = "startsWith";
+    DataEntryRuleDataConditionNames["endsWith"] = "endsWith";
+    DataEntryRuleDataConditionNames["hasLength"] = "hasLength";
+    DataEntryRuleDataConditionNames["matchesRegex"] = "matchesRegex";
+})(DataEntryRuleDataConditionNames = exports.DataEntryRuleDataConditionNames || (exports.DataEntryRuleDataConditionNames = {}));
+var DataEntryRuleTransformationNames;
+(function (DataEntryRuleTransformationNames) {
+    DataEntryRuleTransformationNames["useConstantValue"] = "useConstantValue";
+    DataEntryRuleTransformationNames["useSubstring"] = "useSubstring";
+    DataEntryRuleTransformationNames["useRegexGroupIndex"] = "useRegexGroupIndex";
+    DataEntryRuleTransformationNames["useSubmittedOption"] = "useSubmittedOption";
+    DataEntryRuleTransformationNames["leftPadString"] = "leftPadString";
+    DataEntryRuleTransformationNames["rightPadString"] = "rightPadString";
+    DataEntryRuleTransformationNames["prependString"] = "prependString";
+    DataEntryRuleTransformationNames["appendString"] = "appendString";
+    DataEntryRuleTransformationNames["generateCheckDigit"] = "generateCheckDigit";
+})(DataEntryRuleTransformationNames = exports.DataEntryRuleTransformationNames || (exports.DataEntryRuleTransformationNames = {}));
+//# sourceMappingURL=IDataEntryRuleConfig.js.map

package/lib/domain/model/configuration/IDiscountAttributesConfig .d.ts

@@ -0,0 +1,26 @@
+import { ManualDiscountType } from "@aptos-scp/scp-types-commerce-transaction";
+import { ILabel } from "../Constants";
+import { Reason } from "./IFeatureAccessConfig";
+export interface IDiscountDefinitions {
+    readonly [id: string]: IDiscountDefinition;
+}
+export declare enum ManualDiscountLevel {
+    Transaction = "Transaction",
+    Item = "Item"
+}
+export interface IDiscountDefinition {
+    readonly displayText: ILabel;
+    readonly manualDiscountType: ManualDiscountType;
+    readonly discountValue: string;
+    readonly pricingRuleId?: string;
+    readonly reason?: Reason;
+    readonly couponCode?: string;
+    readonly discountLevel: ManualDiscountLevel;
+}
+export interface IDiscountAttributeList {
+    readonly [id: string]: IDiscountAttributeListDefinition;
+}
+export interface IDiscountAttributeListDefinition {
+    readonly name: ILabel;
+    readonly description: ILabel;
+}

package/lib/domain/model/configuration/IDiscountAttributesConfig .js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ManualDiscountLevel;
+(function (ManualDiscountLevel) {
+    ManualDiscountLevel["Transaction"] = "Transaction";
+    ManualDiscountLevel["Item"] = "Item";
+})(ManualDiscountLevel = exports.ManualDiscountLevel || (exports.ManualDiscountLevel = {}));
+//# sourceMappingURL=IDiscountAttributesConfig .js.map

package/lib/domain/model/configuration/IDiscountBehaviorsConfig.d.ts

@@ -0,0 +1,27 @@
+export declare enum ManualDiscountNameConfigKey {
+    manualRuleId = "manualRuleId",
+    couponRuleId = "couponRuleId",
+    employeeRuleId = "employeeRuleId"
+}
+export declare type IRuleIdOptions = {
+    [key in ManualDiscountNameConfigKey]: number;
+};
+export declare enum ManualDiscountTypeConfigKey {
+    percentage = "percentage",
+    amount = "amount",
+    newPrice = "newPrice",
+    competitivePrice = "competitivePrice"
+}
+export declare type IDiscountTypeOptions = {
+    [key in ManualDiscountTypeConfigKey]: IRuleIdOptions;
+};
+export declare enum ManualDiscountLevelConfigKey {
+    transaction = "transaction",
+    item = "item"
+}
+export declare type IPricingRuleIdMappings = {
+    [key in ManualDiscountLevelConfigKey]: IDiscountTypeOptions;
+};
+export interface IDiscountBehaviorsConfig {
+    pricingRuleIdMappings?: IPricingRuleIdMappings;
+}