Grabbed dndbeyond's source code

```
~/go/bin/sourcemapper -output ddb -jsurl https://media.dndbeyond.com/character-app/static/js/main.90aa78c5.js
```

ddb_main/packages/gfs/lib/FeaturePreprocessor.js

@@ -0,0 +1,134 @@
+import { log, LOG_LEVEL } from './utils/log';
+var FeaturePreprocessor = /** @class */ (function () {
+    function FeaturePreprocessor() {
+        this.featureMap = new Map();
+        this.statementList = [];
+    }
+    FeaturePreprocessor.prototype.process = function (_a) {
+        var rootFeatureIds = _a.rootFeatureIds, featureMap = _a.featureMap;
+        this.featureMap = featureMap;
+        // Add statements from root level features, and their subfeatures.
+        for (var _i = 0, rootFeatureIds_1 = rootFeatureIds; _i < rootFeatureIds_1.length; _i++) {
+            var featureId = rootFeatureIds_1[_i];
+            var feature = featureMap.get(featureId);
+            if (feature === undefined) {
+                log(LOG_LEVEL.ERROR, "Feature " + featureId + " not found");
+            }
+            else {
+                this.deriveStatements(feature, null, null);
+            }
+        }
+        return this.statementList;
+    };
+    FeaturePreprocessor.prototype.deriveStatements = function (feature, featureReferenceId, parameters) {
+        for (var _i = 0, _a = feature.statements; _i < _a.length; _i++) {
+            var statement = _a[_i];
+            // Make a deep copy of the statement. The copy gets the featureReferenceId set.
+            // Also, the engine will be modifying the expressions in the statements, so a deep copy is needed.
+            var statementCopy = JSON.parse(JSON.stringify(statement));
+            if (featureReferenceId !== null && parameters !== null) {
+                // targets might be parameterized
+                statementCopy.target = this.evaluateStatementTarget(statementCopy.target, parameters);
+                // then dive into the statement's expressions to evaluate parameterized static and dynamic values
+                this.processExpression(statementCopy.operand, parameters);
+            }
+            this.statementList.push(statementCopy);
+        }
+        for (var _b = 0, _c = feature.subfeatures; _b < _c.length; _b++) {
+            var featureReference = _c[_b];
+            // the featureReference might also be parameterized, in order to pass parameters down multiple levels
+            var referenceCopy = JSON.parse(JSON.stringify(featureReference)); // copy might not be needed
+            if (parameters !== null) {
+                this.processReferenceParameters(referenceCopy.parameters, parameters);
+            }
+            var subfeatureDef = this.featureMap.get(referenceCopy.featureId);
+            if (subfeatureDef === undefined) {
+                log(LOG_LEVEL.ERROR, "Feature " + referenceCopy.featureId + " not found");
+            }
+            else {
+                this.deriveStatements(subfeatureDef, referenceCopy.featureReferenceId, referenceCopy.parameters);
+            }
+        }
+    };
+    FeaturePreprocessor.prototype.evaluateStatementTarget = function (target, parameters) {
+        var newTargetList = [];
+        for (var i = 0; i < target.length; i++) {
+            var part = target[i];
+            if (typeof part === 'string' && part.startsWith('$inputs.')) {
+                var evaluated = this.lookupInput(part, parameters);
+                if (evaluated === null || evaluated.some(function (x) { return typeof x !== 'string'; })) {
+                    throw new Error('Parameter values for dynamic targets must be strings');
+                }
+                newTargetList.push.apply(newTargetList, evaluated);
+            }
+            else {
+                newTargetList.push(part);
+            }
+        }
+        return newTargetList;
+    };
+    // Some duplicated code here. The difference is that targets must be strings,
+    // while expression parameters might be numbers.
+    FeaturePreprocessor.prototype.evaluateExpressionValues = function (values, parameters) {
+        // An array of strings might turn into an array of numbers, if the parameter values are numbers.
+        // I don't like this :O
+        var evaluatedValues = [];
+        for (var i = 0; i < values.length; i++) {
+            var part = values[i];
+            if (typeof part === 'string' && part.startsWith('$inputs.')) {
+                var evaluated = this.lookupInput(part, parameters);
+                if (evaluated === null) {
+                    throw new Error('Parameter values for static or dynamic values cannot be null');
+                }
+                evaluatedValues.push.apply(evaluatedValues, evaluated);
+            }
+            else {
+                evaluatedValues.push(part);
+            }
+        }
+        if (evaluatedValues.every(function (x) { return typeof x === 'string'; })) {
+            return evaluatedValues;
+        }
+        if (evaluatedValues.every(function (x) { return typeof x === 'number'; })) {
+            return evaluatedValues;
+        }
+        throw new Error('Parameter value type needs to match the type of non-parameterized values');
+    };
+    FeaturePreprocessor.prototype.lookupInput = function (inputName, parameters) {
+        var splits = inputName.split('$inputs.');
+        if (splits.length !== 2) {
+            throw new Error('Invalid $inputs format');
+        }
+        var key = splits[1];
+        if (!parameters.hasOwnProperty(key)) {
+            throw new Error("Parameters is missing key " + key);
+        }
+        return parameters[key]; // TODO: Check to make sure the parameter is there
+    };
+    FeaturePreprocessor.prototype.processExpression = function (expression, parameters) {
+        // If the expression has values, evaluate any $inputs
+        if (expression.values !== null && expression.values.length) {
+            expression.values = this.evaluateExpressionValues(expression.values, parameters);
+        }
+        // If the expression has operands, recurse!
+        if (expression.operands !== null && expression.operands.length) {
+            for (var _i = 0, _a = expression.operands; _i < _a.length; _i++) {
+                var operand = _a[_i];
+                this.processExpression(operand, parameters);
+            }
+        }
+    };
+    FeaturePreprocessor.prototype.processReferenceParameters = function (childParameters, parentParameters) {
+        // FeatureParameters is Record<string, Array<string> | Array<number> | null>
+        var parameterKeys = Object.keys(childParameters);
+        for (var _i = 0, parameterKeys_1 = parameterKeys; _i < parameterKeys_1.length; _i++) {
+            var key = parameterKeys_1[_i];
+            var parameterValues = childParameters[key];
+            if (parameterValues !== null) {
+                childParameters[key] = this.evaluateExpressionValues(parameterValues, parentParameters);
+            }
+        }
+    };
+    return FeaturePreprocessor;
+}());
+export { FeaturePreprocessor };

ddb_main/packages/gfs/lib/LoopResolutionCalculator.js

@@ -0,0 +1,320 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import pkg from 'lodash';
+import { ExpressionOperators } from './types';
+import { log, LOG_LEVEL } from './utils/log';
+var get = pkg.get, set = pkg.set;
+var ADDITIVE_IDENTITY = 0;
+var MULTIPLICATIVE_IDENTITY = 1;
+var ValueUnavailble = /** @class */ (function (_super) {
+    __extends(ValueUnavailble, _super);
+    function ValueUnavailble(message) {
+        return _super.call(this, message) || this;
+    }
+    return ValueUnavailble;
+}(Error));
+function add(state, operands) {
+    var sum = ADDITIVE_IDENTITY;
+    for (var _i = 0, operands_1 = operands; _i < operands_1.length; _i++) {
+        var operand = operands_1[_i];
+        var value = Number(run(state, operand));
+        log(LOG_LEVEL.INFO, ExpressionOperators.ADD + ": value " + value);
+        if (isNaN(value)) {
+            log(LOG_LEVEL.WARN, ExpressionOperators.ADD + ": This was not a number");
+        }
+        else {
+            sum += value;
+        }
+    }
+    log(LOG_LEVEL.INFO, ExpressionOperators.ADD + ": result " + sum);
+    return sum;
+}
+function multiply(state, operands) {
+    var product = MULTIPLICATIVE_IDENTITY;
+    for (var _i = 0, operands_2 = operands; _i < operands_2.length; _i++) {
+        var operand = operands_2[_i];
+        var value = Number(run(state, operand));
+        log(LOG_LEVEL.INFO, ExpressionOperators.ADD + ": value " + value);
+        if (isNaN(value)) {
+            log(LOG_LEVEL.WARN, ExpressionOperators.ADD + ": This was not a number");
+        }
+        else {
+            product *= value;
+        }
+    }
+    log(LOG_LEVEL.INFO, ExpressionOperators.MULTIPLY + ": result " + product);
+    return product;
+}
+function keepHighest() {
+    var rest = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        rest[_i] = arguments[_i];
+    }
+    log(LOG_LEVEL.INFO, "KEEP HIGHEST: options " + String(rest));
+    var result = Math.max.apply(Math, rest.filter(function (x) { return !isNaN(x); }));
+    log(LOG_LEVEL.INFO, "KEEP HIGHEST: result " + result);
+    return result;
+}
+function min(state, operands) {
+    var options = operands.map(function (x) { return run(state, x); });
+    log(LOG_LEVEL.INFO, ExpressionOperators.MIN + ": options " + String(options));
+    var restult = Math.min.apply(Math, options);
+    log(LOG_LEVEL.INFO, ExpressionOperators.MIN + ": result " + restult);
+    return restult;
+}
+function max(state, operands) {
+    var options = operands.map(function (x) { return run(state, x); });
+    log(LOG_LEVEL.INFO, ExpressionOperators.MAX + ": options " + String(options));
+    var restult = Math.max.apply(Math, options);
+    log(LOG_LEVEL.INFO, ExpressionOperators.MAX + ": result " + restult);
+    return restult;
+}
+function getNestedValue(state, path) {
+    return get(state, path);
+}
+function setNestedValue(state, path, value) {
+    if (isNaN(value)) {
+        throw new Error("Value " + value + " is not a number");
+    }
+    set(state, path, value);
+}
+function dynamicValue(state, key) {
+    key = key.flatMap(function (x) { return x.split('.'); });
+    log(LOG_LEVEL.INFO, ExpressionOperators.DYNAMIC_VALUE + ": key " + key);
+    if (!getNestedValue(state, key)) {
+        throw new ValueUnavailble('key not available');
+    }
+    var result = getNestedValue(state, key);
+    log(LOG_LEVEL.INFO, ExpressionOperators.DYNAMIC_VALUE + ": result " + result);
+    return result;
+}
+function floor(state, operand) {
+    return Math.floor(run(state, operand[0]));
+}
+function run(state, operand) {
+    var result;
+    switch (operand.operator) {
+        case ExpressionOperators.STATIC_VALUE: {
+            var values = operand.values;
+            if (!Array.isArray(values)) {
+                throw new Error('STATIC_VALUE has to be an array');
+            }
+            if (!values[0]) {
+                throw new Error('STATIC_VALUE must have a value for index 0');
+            }
+            result = values[0];
+            break;
+        }
+        case ExpressionOperators.DYNAMIC_VALUE: {
+            var values = operand.values;
+            if (!Array.isArray(values) || values.some(function (v) { return typeof v !== 'string'; })) {
+                throw new Error('DYNAMIC_VALUE has to be array of string');
+            }
+            if (!values[0]) {
+                throw new Error('DYNAMIC_VALUE must have a value for index 0');
+            }
+            result = dynamicValue(state, values);
+            break;
+        }
+        case ExpressionOperators.ADD:
+            if (!Array.isArray(operand.operands)) {
+                throw new Error('ADD only supports an array');
+            }
+            result = add(state, operand.operands);
+            break;
+        case ExpressionOperators.MIN:
+            if (!Array.isArray(operand.operands)) {
+                throw new Error('MIN only supports an array');
+            }
+            result = min(state, operand.operands);
+            break;
+        case ExpressionOperators.MAX:
+            if (!Array.isArray(operand.operands)) {
+                throw new Error('MAX only supports an array');
+            }
+            result = max(state, operand.operands);
+            break;
+        case ExpressionOperators.FLOOR:
+            if (!Array.isArray(operand.operands)) {
+                throw new Error('FLOOR not correct format');
+            }
+            result = floor(state, operand.operands);
+            break;
+        case ExpressionOperators.MULTIPLY:
+            if (!Array.isArray(operand.operands)) {
+                throw new Error('MULTIPLY only supports an array');
+            }
+            result = multiply(state, operand.operands);
+            break;
+        default:
+            throw new Error("run: Unknown operator " + operand.operator);
+    }
+    log(LOG_LEVEL.INFO, "Performing " + operand.operator + " :> Result " + result);
+    return result;
+}
+function determineRequirements(operand) {
+    switch (operand.operator) {
+        case 'DYNAMIC_VALUE':
+            if (!operand.values) {
+                throw new Error('DYNAMIC_VALUE reqires values');
+            }
+            return [operand.values.join('.')];
+        case 'STATIC_VALUE':
+            return [];
+        case 'MAX':
+        case 'MIN':
+        case 'ADD':
+        case 'MULTIPLY':
+        case 'FLOOR':
+            if (!Array.isArray(operand.operands)) {
+                throw new Error('no operands array');
+            }
+            var dynamicValueKeys = [];
+            for (var _i = 0, _a = operand.operands; _i < _a.length; _i++) {
+                var childOperand = _a[_i];
+                dynamicValueKeys = dynamicValueKeys.concat(determineRequirements(childOperand));
+            }
+            return dynamicValueKeys;
+        default:
+            throw new Error("determineRequirements: Unknown operator " + operand.operator);
+    }
+}
+function getRequiremets(expression) {
+    if (!expression.operand) {
+        throw new Error('getRequiremets: no operands');
+    }
+    var requirements = determineRequirements(expression.operand);
+    return requirements.filter(function (x) { return x !== expression.target.join('.'); });
+}
+export function runProgram(_a) {
+    var _b;
+    var initState = _a.state, initExpressions = _a.expressions, initTargetResolutionPolicies = _a.targetResolutionPolicies, _c = _a.forceRun, forceRun = _c === void 0 ? false : _c;
+    var state = initState !== null && initState !== void 0 ? initState : {};
+    var expressions = initExpressions !== null && initExpressions !== void 0 ? initExpressions : [];
+    var targetResolutionPolicies = initTargetResolutionPolicies !== null && initTargetResolutionPolicies !== void 0 ? initTargetResolutionPolicies : {};
+    var reprocess = [];
+    var _loop_1 = function (expression) {
+        try {
+            var requirements_1 = getRequiremets(expression);
+            log(LOG_LEVEL.INFO, expression.target + " requires " + requirements_1);
+            var shouldWait = expressions.filter(function (x) { return x !== expression; }).some(function (x) { return requirements_1.includes(x.target.join('.')); }) ||
+                requirements_1.some(function (x) { return !getNestedValue(state, x.split('.')); });
+            log(LOG_LEVEL.ERROR, "Can process " + ((_b = expression.statementId) !== null && _b !== void 0 ? _b : 'id') + " -> " + expression.target + " :> " + (shouldWait ? 'Not yet' : 'Yes'));
+            if (!forceRun && shouldWait) {
+                log(LOG_LEVEL.WARN, "Forcing " + expression.target + " to process");
+                reprocess.push(expression);
+            }
+            else {
+                var result = run(state, expression.operand);
+                if (targetResolutionPolicies.hasOwnProperty(expression.target.join('.'))) {
+                    switch (targetResolutionPolicies[expression.target.join('.')]) {
+                        case 'KEEP_HIGHEST':
+                            setNestedValue(state, expression.target, keepHighest(getNestedValue(state, expression.target), result));
+                            break;
+                        default:
+                            throw new Error('resolution policy not implemented');
+                    }
+                }
+                else {
+                    log(LOG_LEVEL.INFO, "Applying " + expression.target + " = " + result);
+                    setNestedValue(state, expression.target, result);
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof ValueUnavailble) {
+                reprocess.push(expression);
+            }
+            else {
+            }
+        }
+    };
+    for (var _i = 0, expressions_1 = expressions; _i < expressions_1.length; _i++) {
+        var expression = expressions_1[_i];
+        _loop_1(expression);
+    }
+    if (!forceRun && reprocess.length && reprocess.length === expressions.length) {
+        // throw new Error('cannot resolve'); // Tthis is a circular dependency so just run now
+        return runProgram({ state: state, expressions: reprocess, targetResolutionPolicies: targetResolutionPolicies, forceRun: true });
+    }
+    if (!forceRun && reprocess.length) {
+        return runProgram({ state: state, expressions: reprocess, targetResolutionPolicies: targetResolutionPolicies });
+    }
+    return state;
+}
+export function initProgram(_a) {
+    var _b;
+    var initState = _a.state, initExpressions = _a.expressions, initTargetResolutionPolicies = _a.targetResolutionPolicies;
+    var state = initState !== null && initState !== void 0 ? initState : {};
+    var statements = initExpressions !== null && initExpressions !== void 0 ? initExpressions : [];
+    var targetResolutionPolicies = initTargetResolutionPolicies !== null && initTargetResolutionPolicies !== void 0 ? initTargetResolutionPolicies : {};
+    //TODO: consider a init program to run once
+    // const sorted = expressions.sort((a: Statement, b: Statement) => (a?.precedence ?? 0) - (b?.precedence ?? 0));
+    var getSections = function () { return ({
+        noDynamicValues: [],
+        onlySelfDynamics: [],
+        complexDynamics: [],
+    }); };
+    var statementMap = {};
+    for (var i = 0; i < statements.length; i++) {
+        var statement = statements[i];
+        var reqs = determineRequirements(statement.operand);
+        statementMap[statement.precedence] = (_b = statementMap[statement.precedence]) !== null && _b !== void 0 ? _b : getSections();
+        var sections = statementMap[statement.precedence];
+        if (reqs.length === 0) {
+            sections.noDynamicValues.push(statement);
+        }
+        else if (reqs.length === 1 && reqs.includes(statement.target.join('.'))) {
+            sections.onlySelfDynamics.push(statement);
+        }
+        else if (reqs.length > 1 && reqs.includes(statement.target.join('.'))) {
+            sections.onlySelfDynamics.push(statement);
+        }
+        else {
+            sections.complexDynamics.push(statement);
+        }
+    }
+    // const sections = sorted.reduce(
+    //     (sections, expression) => {
+    //         const reqs = determineRequirements(expression.operand);
+    //         if (reqs.length === 0) {
+    //             sections.noDynamicValues.push(expression);
+    //         } else if (reqs.length === 1 && reqs.includes(expression.target)) {
+    //             sections.onlySelfDynamics.push(expression);
+    //         } else {
+    //             sections.complexDynamics.push(expression);
+    //         }
+    //         return sections;
+    //     },
+    //     {
+    //         noDynamicValues: [] as Statement[],
+    //         onlySelfDynamics: [] as Statement[],
+    //         complexDynamics: [] as Statement[],
+    //     },
+    // );
+    var precedences = Object.keys(statementMap).sort(function (a, b) { return Number(a) - Number(b); });
+    for (var i = 0; i < precedences.length; i++) {
+        var precedence = Number(precedences[i]);
+        var precedenceMap = statementMap[precedence];
+        state = runProgram({ state: state, expressions: precedenceMap.noDynamicValues, targetResolutionPolicies: targetResolutionPolicies });
+        state = runProgram({ state: state, expressions: precedenceMap.onlySelfDynamics, targetResolutionPolicies: targetResolutionPolicies });
+        state = runProgram({ state: state, expressions: precedenceMap.complexDynamics, targetResolutionPolicies: targetResolutionPolicies });
+    }
+    log(LOG_LEVEL.INFO, 'STATE:');
+    log(LOG_LEVEL.INFO, JSON.stringify(state, null, 2));
+    return state;
+}
+// runProgram(dynamicAddTest);

ddb_main/packages/gfs/lib/index.js

@@ -0,0 +1,11 @@
+import { FeaturePreprocessor } from './FeaturePreprocessor';
+import { initProgram } from './LoopResolutionCalculator';
+export * from './types';
+export function generateCharacterState(_a) {
+    var rootFeatureIds = _a.rootFeatureIds, featureMap = _a.featureMap;
+    var derivedStatements = new FeaturePreprocessor().process({ rootFeatureIds: rootFeatureIds, featureMap: featureMap });
+    var state = initProgram({
+        expressions: derivedStatements,
+    });
+    return state;
+}

ddb_main/packages/gfs/lib/types.js

@@ -0,0 +1,15 @@
+export var ExpressionOperators;
+(function (ExpressionOperators) {
+    ExpressionOperators["ADD"] = "ADD";
+    ExpressionOperators["MIN"] = "MIN";
+    ExpressionOperators["MAX"] = "MAX";
+    ExpressionOperators["FLOOR"] = "FLOOR";
+    ExpressionOperators["MULTIPLY"] = "MULTIPLY";
+    ExpressionOperators["DYNAMIC_VALUE"] = "DYNAMIC_VALUE";
+    ExpressionOperators["STATIC_VALUE"] = "STATIC_VALUE";
+})(ExpressionOperators || (ExpressionOperators = {}));
+export var StatementOperators;
+(function (StatementOperators) {
+    StatementOperators["SET"] = "SET";
+    StatementOperators["PUSH"] = "PUSH";
+})(StatementOperators || (StatementOperators = {}));

ddb_main/packages/gfs/lib/utils/log.js

@@ -0,0 +1,46 @@
+export var LOG_LEVEL;
+(function (LOG_LEVEL) {
+    LOG_LEVEL[LOG_LEVEL["INFO"] = 0] = "INFO";
+    LOG_LEVEL[LOG_LEVEL["WARN"] = 1] = "WARN";
+    LOG_LEVEL[LOG_LEVEL["ERROR"] = 2] = "ERROR";
+    LOG_LEVEL[LOG_LEVEL["NONE"] = 3] = "NONE";
+})(LOG_LEVEL || (LOG_LEVEL = {}));
+var logLevel = LOG_LEVEL.NONE;
+export function log(level, msg) {
+    if (process.env.NODE_ENV === 'development') {
+        if (level >= logLevel) {
+            switch (level) {
+                case LOG_LEVEL.INFO: {
+                    console.log("%c FEATURE ENGINE :> " + msg + " ", 'background: #aaaaff11; color: #00aaff');
+                    break;
+                }
+                case LOG_LEVEL.WARN: {
+                    console.log("%c FEATURE ENGINE :> " + msg + " ", 'background: #aaffff11; color: #ffffaa');
+                    break;
+                }
+                case LOG_LEVEL.ERROR: {
+                    console.log("%c FEATURE ENGINE :> " + msg + " ", 'background: #ffaaaa11; color: #ff5555');
+                    break;
+                }
+            }
+        }
+    }
+    if (process.env.NODE_ENV === 'test') {
+        if (level >= logLevel) {
+            switch (level) {
+                case LOG_LEVEL.INFO: {
+                    console.log("%c FEATURE ENGINE :> " + msg + " ", 'background: #aaaaff11; color: #00aaff');
+                    break;
+                }
+                case LOG_LEVEL.WARN: {
+                    console.log("%c FEATURE ENGINE :> " + msg + " ", 'background: #aaffff11; color: #ffffaa');
+                    break;
+                }
+                case LOG_LEVEL.ERROR: {
+                    console.log("%c FEATURE ENGINE :> " + msg + " ", 'background: #ffaaaa11; color: #ff5555');
+                    break;
+                }
+            }
+        }
+    }
+}

ddb_main/packages/rules-engine/es/actions/character/actionTypes/action.js

@@ -0,0 +1,12 @@
+export const ACTIONS_SET = 'character.ACTIONS_SET';
+export const ACTIONS_SET_COMMIT = 'character.ACTIONS_SET_COMMIT';
+export const ACTION_USE_SET = 'character.ACTION_USE_SET';
+export const ACTION_USE_SET_COMMIT = 'character.ACTION_USE_SET_COMMIT';
+export const ACTION_CUSTOMIZATIONS_DELETE = 'character.ACTION_CUSTOMIZATIONS_DELETE';
+export const CUSTOM_ACTION_CREATE = 'character.CUSTOM_ACTION_CREATE';
+export const CUSTOM_ACTION_ADD = 'character.CUSTOM_ACTION_ADD';
+export const CUSTOM_ACTION_ADD_COMMIT = 'character.CUSTOM_ACTION_ADD_COMMIT';
+export const CUSTOM_ACTION_SET = 'character.CUSTOM_ACTION_SET';
+export const CUSTOM_ACTION_SET_COMMIT = 'character.CUSTOM_ACTION_SET_COMMIT';
+export const CUSTOM_ACTION_REMOVE = 'character.CUSTOM_ACTION_REMOVE';
+export const CUSTOM_ACTION_REMOVE_COMMIT = 'character.CUSTOM_ACTION_REMOVE_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/background.js

@@ -0,0 +1,8 @@
+export const BACKGROUND_CHOICE_SET_REQUEST = 'character.BACKGROUND_CHOICE_SET_REQUEST';
+export const BACKGROUND_CHOOSE = 'character.BACKGROUND_CHOOSE';
+export const BACKGROUND_CUSTOM_SET_REQUEST = 'character.BACKGROUND_CUSTOM_SET_REQUEST';
+export const BACKGROUND_HAS_CUSTOM_SET_REQUEST = 'character.BACKGROUND_HAS_CUSTOM_SET_REQUEST';
+export const BACKGROUND_HAS_CUSTOM_SET = 'character.BACKGROUND_HAS_CUSTOM_SET';
+export const BACKGROUND_HAS_CUSTOM_SET_COMMIT = 'character.BACKGROUND_HAS_CUSTOM_SET_COMMIT';
+export const BACKGROUND_SET = 'character.BACKGROUND_SET';
+export const BACKGROUND_SET_COMMIT = 'character.BACKGROUND_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/campaignSetting.js

@@ -0,0 +1,3 @@
+export const CAMPAIGN_SETTING_SET_REQUEST = 'character.CAMPAIGN_SETTING_SET_REQUEST';
+export const CAMPAIGN_SETTING_SET = 'character.CAMPAIGN_SETTING_SET';
+export const CAMPAIGN_SETTING_SET_COMMIT = 'character.CAMPAIGN_SETTING_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/character.js

@@ -0,0 +1,101 @@
+export const CHARACTER_LOAD = 'character.CHARACTER_LOAD';
+export const CHARACTER_LOAD_POST_ACTION = 'character.CHARACTER_LOAD_POST_ACTION';
+export const LOAD_LAZY_CHARACTER_DATA = 'character.LOAD_LAZY_CHARACTER_DATA';
+export const NAME_SET = 'character.NAME_SET';
+export const NAME_SET_COMMIT = 'character.NAME_SET_COMMIT';
+export const RANDOM_NAME_REQUEST = 'character.RANDOM_NAME_REQUEST';
+export const ALIGNMENT_SET = 'character.ALIGNMENT_SET';
+export const ALIGNMENT_SET_COMMIT = 'character.ALIGNMENT_SET_COMMIT';
+export const LIFESTYLE_SET = 'character.LIFESTYLE_SET';
+export const LIFESTYLE_SET_COMMIT = 'character.LIFESTYLE_SET_COMMIT';
+export const FAITH_SET = 'character.FAITH_SET';
+export const FAITH_SET_COMMIT = 'character.FAITH_SET_COMMIT';
+export const HAIR_SET = 'character.HAIR_SET';
+export const HAIR_SET_COMMIT = 'character.HAIR_SET_COMMIT';
+export const SKIN_SET = 'character.SKIN_SET';
+export const SKIN_SET_COMMIT = 'character.SKIN_SET_COMMIT';
+export const EYES_SET = 'character.EYES_SET';
+export const EYES_SET_COMMIT = 'character.EYES_SET_COMMIT';
+export const HEIGHT_SET = 'character.HEIGHT_SET';
+export const HEIGHT_SET_COMMIT = 'character.HEIGHT_SET_COMMIT';
+export const WEIGHT_SET = 'character.WEIGHT_SET';
+export const WEIGHT_SET_COMMIT = 'character.WEIGHT_SET_COMMIT';
+export const AGE_SET = 'character.AGE_SET';
+export const AGE_SET_COMMIT = 'character.AGE_SET_COMMIT';
+export const GENDER_SET = 'character.GENDER_SET';
+export const GENDER_SET_COMMIT = 'character.GENDER_SET_COMMIT';
+export const NOTE_SET = 'character.NOTE_SET';
+export const NOTE_SET_COMMIT = 'character.NOTE_SET_COMMIT';
+export const TRAIT_SET = 'character.TRAIT_SET';
+export const TRAIT_SET_COMMIT = 'character.TRAIT_SET_COMMIT';
+export const STARTING_EQUIPMENT_ADD_REQUEST = 'character.STARTING_EQUIPMENT_ADD_REQUEST';
+export const STARTING_GOLD_ADD_REQUEST = 'character.STARTING_GOLD_ADD_REQUEST';
+export const ABILITY_SCORE_SET = 'character.ABILITY_SCORE_SET';
+export const ABILITY_SCORE_BONUS_SET = 'character.ABILITY_SCORE_BONUS_SET';
+export const ABILITY_SCORE_BONUS_SET_COMMIT = 'character.ABILITY_SCORE_BONUS_SET_COMMIT';
+export const ABILITY_SCORE_OVERRIDE_SET = 'character.ABILITY_SCORE_OVERRIDE_SET';
+export const ABILITY_SCORE_OVERRIDE_SET_COMMIT = 'character.ABILITY_SCORE_OVERRIDE_SET_COMMIT';
+export const ABILITY_SCORE_BASE_SET = 'character.ABILITY_SCORE_BASE_SET';
+export const ABILITY_SCORE_BASE_SET_COMMIT = 'character.ABILITY_SCORE_BASE_SET_COMMIT';
+export const MOVEMENT_ADD = 'character.MOVEMENT_ADD';
+export const MOVEMENT_ADD_COMMIT = 'character.MOVEMENT_ADD_COMMIT';
+export const MOVEMENT_SET = 'character.MOVEMENT_SET';
+export const MOVEMENT_SET_COMMIT = 'character.MOVEMENT_SET_COMMIT';
+export const MOVEMENT_REMOVE = 'character.MOVEMENT_REMOVE';
+export const MOVEMENT_REMOVE_COMMIT = 'character.MOVEMENT_REMOVE_COMMIT';
+export const SENSE_ADD = 'character.SENSE_ADD';
+export const SENSE_ADD_COMMIT = 'character.SENSE_ADD_COMMIT';
+export const SENSE_SET = 'character.SENSE_SET';
+export const SENSE_SET_COMMIT = 'character.SENSE_SET_COMMIT';
+export const SENSE_REMOVE = 'character.SENSE_REMOVE';
+export const SENSE_REMOVE_COMMIT = 'character.SENSE_REMOVE_COMMIT';
+export const CUSTOM_PROFICIENCY_CREATE = 'character.CUSTOM_PROFICIENCY_CREATE';
+export const CUSTOM_PROFICIENCY_ADD = 'character.CUSTOM_PROFICIENCY_ADD';
+export const CUSTOM_PROFICIENCY_ADD_COMMIT = 'character.CUSTOM_PROFICIENCY_ADD_COMMIT';
+export const CUSTOM_PROFICIENCY_SET = 'character.CUSTOM_PROFICIENCY_SET';
+export const CUSTOM_PROFICIENCY_SET_COMMIT = 'character.CUSTOM_PROFICIENCY_SET_COMMIT';
+export const CUSTOM_PROFICIENCY_REMOVE = 'character.CUSTOM_PROFICIENCY_REMOVE';
+export const CUSTOM_PROFICIENCY_REMOVE_COMMIT = 'character.CUSTOM_PROFICIENCY_REMOVE_COMMIT';
+export const CUSTOM_DEFENSE_ADJUSTMENT_ADD = 'character.CUSTOM_DEFENSE_ADJUSTMENT_ADD';
+export const CUSTOM_DEFENSE_ADJUSTMENT_ADD_COMMIT = 'character.CUSTOM_DEFENSE_ADJUSTMENT_ADD_COMMIT';
+export const CUSTOM_DEFENSE_ADJUSTMENT_SET = 'character.CUSTOM_DEFENSE_ADJUSTMENT_SET';
+export const CUSTOM_DEFENSE_ADJUSTMENT_SET_COMMIT = 'character.CUSTOM_DEFENSE_ADJUSTMENT_SET_COMMIT';
+export const CUSTOM_DEFENSE_ADJUSTMENT_REMOVE = 'character.CUSTOM_DEFENSE_ADJUSTMENT_REMOVE';
+export const CUSTOM_DEFENSE_ADJUSTMENT_REMOVE_COMMIT = 'character.CUSTOM_DEFENSE_ADJUSTMENT_REMOVE_COMMIT';
+export const XP_SET = 'character.XP_SET';
+export const XP_SET_COMMIT = 'character.XP_SET_COMMIT';
+export const XP_SET_REQUEST = 'character.XP_SET_REQUEST';
+export const BASE_HIT_POINTS_SET = 'character.BASE_HIT_POINTS_SET';
+export const BASE_HIT_POINTS_SET_COMMIT = 'character.BASE_HIT_POINTS_SET_COMMIT';
+export const HIT_POINTS_SET = 'character.HIT_POINTS_SET';
+export const HIT_POINTS_SET_COMMIT = 'character.HIT_POINTS_SET_COMMIT';
+export const BONUS_HIT_POINTS_SET = 'character.BONUS_HIT_POINTS_SET';
+export const BONUS_HIT_POINTS_SET_COMMIT = 'character.BONUS_HIT_POINTS_SET_COMMIT';
+export const OVERRIDE_HIT_POINTS_SET = 'character.OVERRIDE_HIT_POINTS_SET';
+export const OVERRIDE_HIT_POINTS_SET_COMMIT = 'character.OVERRIDE_HIT_POINTS_SET_COMMIT';
+export const DEATHSAVES_SET = 'character.DEATHSAVES_SET';
+export const DEATHSAVES_SET_COMMIT = 'character.DEATHSAVES_SET_COMMIT';
+export const RESTORE_LIFE = 'character.RESTORE_LIFE';
+export const SHORT_REST = 'character.SHORT_REST';
+export const SHORT_REST_COMMIT = 'character.SHORT_REST_COMMIT';
+export const LONG_REST = 'character.LONG_REST';
+export const LONG_REST_COMMIT = 'character.LONG_REST_COMMIT';
+export const CURRENCIES_SET = 'character.CURRENCIES_SET';
+export const CURRENCIES_SET_COMMIT = 'character.CURRENCIES_SET_COMMIT';
+export const CURRENCY_TRANSACTION_SET = 'character.CURRENCY_TRANSACTION_SET';
+export const CURRENCY_COPPER_SET = 'character.CURRENCY_COPPER_SET';
+export const CURRENCY_COPPER_SET_COMMIT = 'character.CURRENCY_COPPER_SET_COMMIT';
+export const CURRENCY_ELECTRUM_SET = 'character.CURRENCY_ELECTRUM_SET';
+export const CURRENCY_ELECTRUM_SET_COMMIT = 'character.CURRENCY_ELECTRUM_SET_COMMIT';
+export const CURRENCY_GOLD_SET = 'character.CURRENCY_GOLD_SET';
+export const CURRENCY_GOLD_SET_COMMIT = 'character.CURRENCY_GOLD_SET_COMMIT';
+export const CURRENCY_PLATINUM_SET = 'character.CURRENCY_PLATINUM_SET';
+export const CURRENCY_PLATINUM_SET_COMMIT = 'character.CURRENCY_PLATINUM_SET_COMMIT';
+export const CURRENCY_SILVER_SET = 'character.CURRENCY_SILVER_SET';
+export const CURRENCY_SILVER_SET_COMMIT = 'character.CURRENCY_SILVER_SET_COMMIT';
+export const INSPIRATION_SET = 'character.INSPIRATION_SET';
+export const INSPIRATION_SET_COMMIT = 'character.INSPIRATION_SET_COMMIT';
+export const STATUS_SET = 'character.STATUS_SET';
+export const STATUS_SET_COMMIT = 'character.STATUS_SET_COMMIT';
+export const STATUS_SLUG_SET = 'character.STATUS_SLUG_SET';
+export const STATUS_SLUG_SET_COMMIT = 'character.STATUS_SLUG_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/choice.js

@@ -0,0 +1,2 @@
+export const CHOICES_SET = 'character.CHOICES_SET';
+export const CHOICES_SET_COMMIT = 'character.CHOICES_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/class.js

@@ -0,0 +1,13 @@
+export const INITIAL_CLASS_SET = 'character.INITIAL_CLASS_SET';
+export const CLASS_ADD = 'character.CLASS_ADD';
+export const CLASS_ADD_REQUEST = 'character.CLASS_ADD_REQUEST';
+export const CLASS_ADD_POST_ACTION = 'character.CLASS_ADD_POST_ACTION';
+export const CLASS_REMOVE_REQUEST = 'character.CLASS_REMOVE_REQUEST';
+export const CLASS_REMOVE_POST_ACTION = 'character.CLASS_REMOVE_POST_ACTION';
+export const CLASS_REMOVE_COMMIT = 'character.CLASS_REMOVE_COMMIT';
+export const CLASS_SET = 'character.CLASS_SET';
+export const CLASS_SET_COMMIT = 'character.CLASS_SET_COMMIT';
+export const CLASS_LEVEL_SET_REQUEST = 'character.CLASS_LEVEL_SET_REQUEST';
+export const CLASSES_SET = 'character.CLASSES_SET';
+export const CLASSES_SET_COMMIT = 'character.CLASSES_SET_COMMIT';
+export const CLASSES_UNSET = 'character.CLASSES_UNSET';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/classFeature.js

@@ -0,0 +1 @@
+export const CLASS_FEATURE_CHOICE_SET_REQUEST = 'character.CLASS_FEATURE_CHOICE_SET_REQUEST';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/condition.js

@@ -0,0 +1,5 @@
+export const CONDITION_SET = 'character.CONDITION_SET';
+export const CONDITION_ADD = 'character.CONDITION_ADD';
+export const CONDITION_REMOVE = 'character.CONDITION_REMOVE';
+export const CONDITIONS_SET = 'character.CONDITIONS_SET';
+export const CONDITIONS_SET_COMMIT = 'character.CONDITIONS_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/configuration.js

@@ -0,0 +1,6 @@
+export const SHOW_HELP_TEXT_SET = 'character.SHOW_HELP_TEXT_SET';
+export const SHOW_HELP_TEXT_SET_REQUEST = 'character.SHOW_HELP_TEXT_SET_REQUEST';
+export const ABILITY_SCORE_TYPE_SET_REQUEST = 'character.ABILITY_SCORE_TYPE_SET_REQUEST';
+export const ABILITY_SCORE_TYPE_SET_COMMIT = 'character.ABILITY_SCORE_TYPE_SET_COMMIT';
+export const STARTING_EQUIPMENT_TYPE_SET = 'character.STARTING_EQUIPMENT_TYPE_SET';
+export const STARTING_EQUIPMENT_TYPE_SET_COMMIT = 'character.STARTING_EQUIPMENT_TYPE_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/core.js

@@ -0,0 +1,11 @@
+export const CHARACTER_SET = 'character.CHARACTER_SET';
+export const CHARACTER_COMPONENTS_SET = 'character.CHARACTER_COMPONENTS_SET';
+export const CHARACTER_COMPONENTS_SET_COMMIT = 'character.CHARACTER_COMPONENTS_SET_COMMIT';
+export const ACTIVE_SOURCE_CATEGORIES_SET = 'character.ACTIVE_SOURCE_CATEGORIES_SET';
+export const ACTIVE_SOURCE_CATEGORIES_SET_COMMIT = 'character.ACTIVE_SOURCE_CATEGORIES_SET_COMMIT';
+export const ACTIVE_SOURCES_SET = 'character.ACTIVE_SOURCES_SET';
+export const ACTIVE_SOURCES_SET_COMMIT = 'character.ACTIVE_SOURCES_SET_COMMIT';
+export const PREFERENCE_CHOOSE = 'character.PREFERENCE_CHOOSE';
+export const PREFERENCE_SET = 'character.PREFERENCE_SET';
+export const PREFERENCE_SET_COMMIT = 'character.PREFERENCE_SET_COMMIT';
+export const SEND_SOCIAL_IMAGE_DATA = 'character.SEND_SOCIAL_IMAGE_DATA';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/creature.js

@@ -0,0 +1,12 @@
+export const CREATURE_CREATE = 'character.CREATURE_CREATE';
+export const CREATURE_ADD = 'character.CREATURE_ADD';
+export const CREATURE_ADD_COMMIT = 'character.CREATURE_ADD_COMMIT';
+export const CREATURE_REMOVE = 'character.CREATURE_REMOVE';
+export const CREATURE_REMOVE_COMMIT = 'character.CREATURE_REMOVE_COMMIT';
+export const CREATURE_DATA_SET = 'character.CREATURE_DATA_SET';
+export const CREATURE_DATA_SET_COMMIT = 'character.CREATURE_DATA_SET_COMMIT';
+export const CREATURE_HIT_POINTS_SET = 'character.CREATURE_HIT_POINTS_SET';
+export const CREATURE_HIT_POINTS_SET_COMMIT = 'character.CREATURE_HIT_POINTS_SET_COMMIT';
+export const CREATURE_ACTIVE_SET = 'character.CREATURE_ACTIVE_SET';
+export const CREATURE_ACTIVE_SET_COMMIT = 'character.CREATURE_ACTIVE_SET_COMMIT';
+export const CREATURE_CUSTOMIZATIONS_DELETE = 'character.CREATURE_CUSTOMIZATIONS_DELETE';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/decoration.js

@@ -0,0 +1,9 @@
+export const BACKDROP_SET = 'character.BACKDROP_SET';
+export const BACKDROP_SET_COMMIT = 'character.BACKDROP_SET_COMMIT';
+export const FRAME_SET = 'character.FRAME_SET';
+export const FRAME_SET_COMMIT = 'character.FRAME_SET_COMMIT';
+export const THEME_SET = 'character.THEME_SET';
+export const THEME_SET_COMMIT = 'character.THEME_SET_COMMIT';
+export const PORTRAIT_SET = 'character.PORTRAIT_SET';
+export const PORTRAIT_SET_COMMIT = 'character.PORTRAIT_SET_COMMIT';
+export const PORTRAIT_UPLOAD = 'character.PORTRAIT_UPLOAD';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/feat.js

@@ -0,0 +1,6 @@
+export const FEAT_CHOICE_SET_REQUEST = 'character.FEAT_CHOICE_SET_REQUEST';
+export const FEATS_SET = 'character.FEATS_SET';
+export const FEATS_SET_COMMIT = 'character.FEATS_SET_COMMIT';
+export const ADHOC_FEAT_CREATE = 'character.ADHOC_FEAT_CREATE';
+export const ADHOC_FEAT_REMOVE = 'character.ADHOC_FEAT_REMOVE';
+export const SET_ENTITY_FEAT = 'character.SET_ENTITY_FEAT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/item.js

@@ -0,0 +1,39 @@
+export const ITEM_CREATE = 'character.ITEM_CREATE';
+export const ITEM_ADD = 'character.ITEM_ADD';
+export const ITEM_ADD_COMMIT = 'character.ITEM_ADD_COMMIT';
+export const ITEM_REMOVE = 'character.ITEM_REMOVE';
+export const ITEM_REMOVE_COMMIT = 'character.ITEM_REMOVE_COMMIT';
+export const ITEM_DESTROY = 'character.ITEM_DESTROY';
+export const ITEM_MOVE_SET = 'character.ITEM_MOVE_SET';
+export const ITEM_MOVE_SET_COMMIT = 'character.ITEM_MOVE_SET_COMMIT';
+export const ITEM_EQUIPPED_SET = 'character.ITEM_EQUIPPED_SET';
+export const ITEM_EQUIPPED_SET_COMMIT = 'character.ITEM_EQUIPPED_SET_COMMIT';
+export const ITEM_ATTUNE_SET = 'character.ITEM_ATTUNE_SET';
+export const ITEM_ATTUNE_SET_COMMIT = 'character.ITEM_ATTUNE_SET_COMMIT';
+export const ITEM_QUANTITY_SET = 'character.ITEM_QUANTITY_SET';
+export const ITEM_QUANTITY_SET_COMMIT = 'character.ITEM_QUANTITY_SET_COMMIT';
+export const ITEM_CHARGES_SET = 'character.ITEM_CHARGES_SET';
+export const ITEM_CHARGES_SET_COMMIT = 'character.ITEM_CHARGES_SET_COMMIT';
+export const ITEM_DISPLAY_AS_ATTACK_SET = 'character.ITEM_DISPLAY_AS_ATTACK_SET';
+export const ITEM_DISPLAY_AS_ATTACK_SET_COMMIT = 'character.ITEM_DISPLAY_AS_ATTACK_SET_COMMIT';
+export const ITEM_CUSTOMIZATIONS_DELETE = 'character.ITEM_CUSTOMIZATIONS_DELETE';
+export const CUSTOM_ITEM_CREATE = 'character.CUSTOM_ITEM_CREATE';
+export const CUSTOM_ITEM_DESTROY = 'character.CUSTOM_ITEM_DESTROY';
+export const CUSTOM_ITEM_ADD = 'character.CUSTOM_ITEM_ADD';
+export const CUSTOM_ITEM_ADD_COMMIT = 'character.CUSTOM_ITEM_ADD_COMMIT';
+export const CUSTOM_ITEM_REMOVE = 'character.CUSTOM_ITEM_REMOVE';
+export const CUSTOM_ITEM_REMOVE_COMMIT = 'character.CUSTOM_ITEM_REMOVE_COMMIT';
+export const CUSTOM_ITEM_SET = 'character.CUSTOM_ITEM_SET';
+export const CUSTOM_ITEM_SET_COMMIT = 'character.CUSTOM_ITEM_SET_COMMIT';
+export const ITEM_CURRENCY_SET = 'character.ITEM_CURRENCY_SET';
+export const ITEM_CURRENCY_SET_COMMIT = 'character.ITEM_CURRENCY_SET_COMMIT';
+export const ITEM_CURRENCY_COPPER_SET = 'character.ITEM_CURRENCY_COPPER_SET';
+export const ITEM_CURRENCY_COPPER_SET_COMMIT = 'character.ITEM_CURRENCY_COPPER_SET_COMMIT';
+export const ITEM_CURRENCY_ELECTRUM_SET = 'character.ITEM_CURRENCY_ELECTRUM_SET';
+export const ITEM_CURRENCY_ELECTRUM_SET_COMMIT = 'character.ITEM_CURRENCY_ELECTRUM_SET_COMMIT';
+export const ITEM_CURRENCY_GOLD_SET = 'character.ITEM_CURRENCY_GOLD_SET';
+export const ITEM_CURRENCY_GOLD_SET_COMMIT = 'character.ITEM_CURRENCY_GOLD_SET_COMMIT';
+export const ITEM_CURRENCY_PLATINUM_SET = 'character.ITEM_CURRENCY_PLATINUM_SET';
+export const ITEM_CURRENCY_PLATINUM_SET_COMMIT = 'character.ITEM_CURRENCY_PLATINUM_SET_COMMIT';
+export const ITEM_CURRENCY_SILVER_SET = 'character.ITEM_CURRENCY_SILVER_SET';
+export const ITEM_CURRENCY_SILVER_SET_COMMIT = 'character.ITEM_CURRENCY_SILVER_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/modifier.js

@@ -0,0 +1,2 @@
+export const MODIFIERS_SET = 'character.MODIFIERS_SET';
+export const MODIFIERS_SET_COMMIT = 'character.MODIFIERS_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/option.js

@@ -0,0 +1,2 @@
+export const OPTIONS_SET = 'character.OPTIONS_SET';
+export const OPTIONS_SET_COMMIT = 'character.OPTIONS_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/optionalClassFeature.js

@@ -0,0 +1,9 @@
+export const OPTIONAL_CLASS_FEATURE_CREATE = 'character.OPTIONAL_CLASS_FEATURE_CREATE';
+export const OPTIONAL_CLASS_FEATURE_ADD = 'character.OPTIONAL_CLASS_FEATURE_ADD';
+export const OPTIONAL_CLASS_FEATURE_ADD_COMMIT = 'character.OPTIONAL_CLASS_FEATURE_ADD_COMMIT';
+export const OPTIONAL_CLASS_FEATURE_SET_REQUEST = 'character.OPTIONAL_CLASS_FEATURE_SET_REQUEST';
+export const OPTIONAL_CLASS_FEATURE_SET = 'character.OPTIONAL_CLASS_FEATURE_SET';
+export const OPTIONAL_CLASS_FEATURE_SET_COMMIT = 'character.OPTIONAL_CLASS_FEATURE_SET_COMMIT';
+export const OPTIONAL_CLASS_FEATURE_DESTROY = 'character.OPTIONAL_CLASS_FEATURE_DESTROY';
+export const OPTIONAL_CLASS_FEATURE_REMOVE = 'character.OPTIONAL_CLASS_FEATURE_REMOVE';
+export const OPTIONAL_CLASS_FEATURE_REMOVE_COMMIT = 'character.OPTIONAL_CLASS_FEATURE_REMOVE_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/optionalOrigin.js

@@ -0,0 +1,9 @@
+export const OPTIONAL_ORIGIN_CREATE = 'character.OPTIONAL_ORIGIN_CREATE';
+export const OPTIONAL_ORIGIN_ADD = 'character.OPTIONAL_ORIGIN_ADD';
+export const OPTIONAL_ORIGIN_ADD_COMMIT = 'character.OPTIONAL_ORIGIN_ADD_COMMIT';
+export const OPTIONAL_ORIGIN_SET_REQUEST = 'character.OPTIONAL_ORIGIN_SET_REQUEST';
+export const OPTIONAL_ORIGIN_SET = 'character.OPTIONAL_ORIGIN_SET';
+export const OPTIONAL_ORIGIN_SET_COMMIT = 'character.OPTIONAL_ORIGIN_SET_COMMIT';
+export const OPTIONAL_ORIGIN_DESTROY = 'character.OPTIONAL_ORIGIN_DESTROY';
+export const OPTIONAL_ORIGIN_REMOVE = 'character.OPTIONAL_ORIGIN_REMOVE';
+export const OPTIONAL_ORIGIN_REMOVE_COMMIT = 'character.OPTIONAL_ORIGIN_REMOVE_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/premadeInfo.js

@@ -0,0 +1,6 @@
+export const PREMADE_INFO_ADD = 'character.PREMADE_INFO_ADD';
+export const PREMADE_INFO_GET = 'character.PREMADE_INFO_GET';
+export const PREMADE_INFO_UPDATE = 'character.PREMADE_INFO_UPDATE';
+export const PREMADE_INFO_DELETE = 'character.PREMADE_INFO_DELETE';
+export const PREMADE_INFO_SET_COMMIT = 'character.PREMADE_INFO_SET_COMMIT';
+export const PREMADE_INFO_REMOVE_COMMIT = 'character.PREMADE_INFO_REMOVE_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/race.js

@@ -0,0 +1,5 @@
+export const RACE_CHOOSE = 'character.RACE_CHOOSE';
+export const RACE_CHOOSE_POST_ACTION = 'character.RACE_CHOOSE_POST_ACTION';
+export const RACE_SET = 'character.RACE_SET';
+export const RACE_SET_COMMIT = 'character.RACE_SET_COMMIT';
+export const RACE_UNSET = 'character.RACE_UNSET';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/racialTrait.js

@@ -0,0 +1 @@
+export const RACIAL_TRAIT_CHOICE_SET_REQUEST = 'character.RACIAL_TRAIT_CHOICE_SET_REQUEST';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/spell.js

@@ -0,0 +1,24 @@
+export const SPELL_CREATE = 'character.SPELL_CREATE';
+export const SPELL_ADD = 'character.SPELL_ADD';
+export const SPELL_ADD_COMMIT = 'character.SPELL_ADD_COMMIT';
+export const SPELL_REMOVE = 'character.SPELL_REMOVE';
+export const SPELL_REMOVE_COMMIT = 'character.SPELL_REMOVE_COMMIT';
+export const SPELL_PREPARED_SET = 'character.SPELL_PREPARED_SET';
+export const SPELL_PREPARED_SET_COMMIT = 'character.SPELL_PREPARED_SET_COMMIT';
+export const SPELL_USE_SET = 'character.SPELL_USE_SET';
+export const SPELL_USE_SET_COMMIT = 'character.SPELL_USE_SET_COMMIT';
+export const SPELL_LEVEL_SPELL_SLOTS_SET = 'character.SPELL_LEVEL_SPELL_SLOTS_SET';
+export const SPELL_LEVEL_SPELL_SLOTS_SET_COMMIT = 'character.SPELL_LEVEL_SPELL_SLOTS_SET_COMMIT';
+export const PACT_MAGIC_SET = 'character.PACT_MAGIC_SET';
+export const PACT_MAGIC_SET_COMMIT = 'character.PACT_MAGIC_SET_COMMIT';
+export const SPELL_LEVEL_PACT_MAGIC_SLOTS_SET = 'character.SPELL_LEVEL_PACT_MAGIC_SLOTS_SET';
+export const SPELL_LEVEL_PACT_MAGIC_SLOTS_SET_COMMIT = 'character.SPELL_LEVEL_PACT_MAGIC_SLOTS_SET_COMMIT';
+export const SPELL_DISPLAY_AS_ATTACK_SET = 'character.SPELL_DISPLAY_AS_ATTACK_SET';
+export const SPELL_DISPLAY_AS_ATTACK_SET_COMMIT = 'character.SPELL_DISPLAY_AS_ATTACK_SET_COMMIT';
+export const SPELL_FEATURE_DISPLAY_AS_ATTACK_SET = 'character.SPELL_FEATURE_DISPLAY_AS_ATTACK_SET';
+export const SPELL_FEATURE_DISPLAY_AS_ATTACK_SET_COMMIT = 'character.SPELL_FEATURE_DISPLAY_AS_ATTACK_SET_COMMIT';
+export const SPELL_CUSTOMIZATIONS_DELETE = 'character.SPELL_CUSTOMIZATIONS_DELETE';
+export const SPELLS_SLOTS_SET = 'character.SPELLS_SLOTS_SET';
+export const SPELLS_SLOTS_SET_COMMIT = 'character.SPELLS_SLOTS_SET_COMMIT';
+export const CHARACTER_SPELLS_SET = 'character.CHARACTER_SPELLS_SET';
+export const CHARACTER_SPELLS_SET_COMMIT = 'character.CHARACTER_SPELLS_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actionTypes/value.js

@@ -0,0 +1,6 @@
+export const VALUE_SET = 'character.VALUE_SET';
+export const VALUE_SET_COMMIT = 'character.VALUE_SET_COMMIT';
+export const VALUE_REMOVE = 'character.VALUE_REMOVE';
+export const VALUE_REMOVE_COMMIT = 'character.VALUE_REMOVE_COMMIT';
+export const ENTITY_VALUES_REMOVE = 'character.ENTITY_VALUES_REMOVE';
+export const ENTITY_VALUES_REMOVE_COMMIT = 'character.ENTITY_VALUES_REMOVE_COMMIT';

ddb_main/packages/rules-engine/es/actions/character/actions/action.js

@@ -0,0 +1,124 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param name
+ * @param actionType
+ */
+export function customActionCreate(name, actionType) {
+    return {
+        type: actionTypes.CUSTOM_ACTION_CREATE,
+        payload: {
+            name,
+            actionType,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param actions
+ */
+export function actionsSet(actions) {
+    return {
+        type: actionTypes.ACTIONS_SET,
+        payload: {
+            actions,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ACTIONS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param entityTypeId
+ * @param uses
+ * @param dataOriginType
+ */
+export function actionUseSet(id, entityTypeId, uses, dataOriginType) {
+    return {
+        type: actionTypes.ACTION_USE_SET,
+        payload: {
+            id,
+            entityTypeId,
+            uses,
+            dataOriginType,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ACTION_USE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param action
+ */
+export function customActionAdd(action) {
+    return {
+        type: actionTypes.CUSTOM_ACTION_ADD,
+        payload: {
+            action,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_ACTION_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function customActionRemove(id) {
+    return {
+        type: actionTypes.CUSTOM_ACTION_REMOVE,
+        payload: {
+            id,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_ACTION_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param properties
+ */
+export function customActionSet(id, properties) {
+    return {
+        type: actionTypes.CUSTOM_ACTION_SET,
+        payload: {
+            id,
+            properties,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_ACTION_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param mappingId
+ * @param mappingEntityTypeId
+ */
+export function actionCustomizationsDelete(mappingId, mappingEntityTypeId) {
+    return {
+        type: actionTypes.ACTION_CUSTOMIZATIONS_DELETE,
+        payload: {
+            mappingId,
+            mappingEntityTypeId,
+        },
+        meta: {},
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/background.js

@@ -0,0 +1,91 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param backgroundId
+ */
+export function backgroundChoose(backgroundId) {
+    return {
+        type: actionTypes.BACKGROUND_CHOOSE,
+        payload: {
+            backgroundId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param background
+ */
+export function backgroundSet(background) {
+    return {
+        type: actionTypes.BACKGROUND_SET,
+        payload: {
+            background,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.BACKGROUND_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param choiceType
+ * @param choiceId
+ * @param optionValue
+ */
+export function backgroundChoiceSetRequest(choiceType, choiceId, optionValue) {
+    return {
+        type: actionTypes.BACKGROUND_CHOICE_SET_REQUEST,
+        payload: {
+            choiceType,
+            choiceId,
+            optionValue,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param hasCustomBackground
+ */
+export function backgroundHasCustomSet(hasCustomBackground) {
+    return {
+        type: actionTypes.BACKGROUND_HAS_CUSTOM_SET,
+        payload: {
+            hasCustomBackground,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.BACKGROUND_HAS_CUSTOM_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param hasCustomBackground
+ */
+export function backgroundHasCustomSetRequest(hasCustomBackground) {
+    return {
+        type: actionTypes.BACKGROUND_HAS_CUSTOM_SET_REQUEST,
+        payload: {
+            hasCustomBackground,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param properties
+ */
+export function backgroundCustomSetRequest(properties) {
+    return {
+        type: actionTypes.BACKGROUND_CUSTOM_SET_REQUEST,
+        payload: {
+            properties,
+        },
+        meta: {},
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/campaignSetting.js

@@ -0,0 +1,28 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param racialTraitId
+ * @param affectedRacialTraitId
+ */
+export function campaignSettingSetRequest(CampaignSettingContract) {
+    return {
+        type: actionTypes.CAMPAIGN_SETTING_SET_REQUEST,
+        payload: Object.assign({}, CampaignSettingContract),
+        meta: {},
+    };
+}
+/**
+ *
+ * @param CustomCampaignSettingContract
+ */
+export function campaignSettingSet(CampaignSettingContract) {
+    return {
+        type: actionTypes.CAMPAIGN_SETTING_SET,
+        payload: Object.assign({}, CampaignSettingContract),
+        meta: {
+            commit: {
+                type: actionTypes.CAMPAIGN_SETTING_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/character.js

@@ -0,0 +1,936 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ */
+export function characterLoad(characterId, requestParams = {}, config = {}) {
+    return {
+        type: actionTypes.CHARACTER_LOAD,
+        payload: {
+            characterId,
+            requestParams,
+            config: Object.assign({ includeAlwaysKnownSpells: false }, config),
+        },
+        meta: {
+            postAction: {
+                type: [actionTypes.CHARACTER_LOAD_POST_ACTION],
+            },
+        },
+    };
+}
+export function loadLazyCharacterData() {
+    return {
+        type: actionTypes.LOAD_LAZY_CHARACTER_DATA,
+        payload: {},
+        meta: {},
+    };
+}
+/**
+ *
+ * @param currentXp
+ */
+export function xpSetRequest(currentXp) {
+    return {
+        type: actionTypes.XP_SET_REQUEST,
+        payload: {
+            currentXp,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param currentXp
+ */
+export function xpSet(currentXp) {
+    return {
+        type: actionTypes.XP_SET,
+        payload: {
+            currentXp,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.XP_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ */
+export function randomNameRequest() {
+    return {
+        type: actionTypes.RANDOM_NAME_REQUEST,
+        payload: {},
+        meta: {},
+    };
+}
+/**
+ *
+ * @param name
+ */
+export function nameSet(name) {
+    return {
+        type: actionTypes.NAME_SET,
+        payload: {
+            name,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.NAME_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param restoreType
+ */
+export function restoreLife(restoreType) {
+    return {
+        type: actionTypes.RESTORE_LIFE,
+        payload: {
+            restoreType,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param name
+ * @param type
+ */
+export function customProficiencyCreate(name, type) {
+    return {
+        type: actionTypes.CUSTOM_PROFICIENCY_CREATE,
+        payload: {
+            name,
+            type,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param classHitDiceUsed
+ * @param resetMaxHpModifier
+ */
+export function shortRest(classHitDiceUsed, resetMaxHpModifier) {
+    return {
+        type: actionTypes.SHORT_REST,
+        payload: {
+            classHitDiceUsed,
+            resetMaxHpModifier,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param resetMaxHpModifier
+ * @param adjustConditionLevel
+ */
+export function longRest(resetMaxHpModifier, adjustConditionLevel) {
+    return {
+        type: actionTypes.LONG_REST,
+        payload: {
+            resetMaxHpModifier,
+            adjustConditionLevel,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param noteType
+ * @param content
+ */
+export function noteSet(noteType, content) {
+    return {
+        type: actionTypes.NOTE_SET,
+        payload: {
+            noteType,
+            content,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.NOTE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param traitType
+ * @param content
+ */
+export function traitSet(traitType, content) {
+    return {
+        type: actionTypes.TRAIT_SET,
+        payload: {
+            traitType,
+            content,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.TRAIT_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param baseHitPoints
+ */
+export function baseHitPointsSet(baseHitPoints) {
+    return {
+        type: actionTypes.BASE_HIT_POINTS_SET,
+        payload: {
+            baseHitPoints,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.BASE_HIT_POINTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param bonusHitPoints
+ */
+export function bonusHitPointsSet(bonusHitPoints) {
+    return {
+        type: actionTypes.BONUS_HIT_POINTS_SET,
+        payload: {
+            bonusHitPoints,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.BONUS_HIT_POINTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param overrideHitPoints
+ */
+export function overrideHitPointsSet(overrideHitPoints) {
+    return {
+        type: actionTypes.OVERRIDE_HIT_POINTS_SET,
+        payload: {
+            overrideHitPoints,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.OVERRIDE_HIT_POINTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param statId
+ * @param type
+ * @param value
+ */
+export function abilityScoreSet(statId, type, value) {
+    return {
+        type: actionTypes.ABILITY_SCORE_SET,
+        payload: {
+            statId,
+            type,
+            value,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param hair
+ */
+export function hairSet(hair) {
+    return {
+        type: actionTypes.HAIR_SET,
+        payload: {
+            hair,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.HAIR_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param skin
+ */
+export function skinSet(skin) {
+    return {
+        type: actionTypes.SKIN_SET,
+        payload: {
+            skin,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.SKIN_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param eyes
+ */
+export function eyesSet(eyes) {
+    return {
+        type: actionTypes.EYES_SET,
+        payload: {
+            eyes,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.EYES_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param height
+ */
+export function heightSet(height) {
+    return {
+        type: actionTypes.HEIGHT_SET,
+        payload: {
+            height,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.HEIGHT_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param weight
+ */
+export function weightSet(weight) {
+    return {
+        type: actionTypes.WEIGHT_SET,
+        payload: {
+            weight,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.WEIGHT_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param age
+ */
+export function ageSet(age) {
+    return {
+        type: actionTypes.AGE_SET,
+        payload: {
+            age,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.AGE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param gender
+ */
+export function genderSet(gender) {
+    return {
+        type: actionTypes.GENDER_SET,
+        payload: {
+            gender,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.GENDER_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param alignmentId
+ */
+export function alignmentSet(alignmentId) {
+    return {
+        type: actionTypes.ALIGNMENT_SET,
+        payload: {
+            alignmentId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ALIGNMENT_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param lifestyleId
+ */
+export function lifestyleSet(lifestyleId) {
+    return {
+        type: actionTypes.LIFESTYLE_SET,
+        payload: {
+            lifestyleId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.LIFESTYLE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param faith
+ */
+export function faithSet(faith) {
+    return {
+        type: actionTypes.FAITH_SET,
+        payload: {
+            faith,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.FAITH_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param removedHitPoints
+ * @param temporaryHitPoints
+ */
+export function hitPointsSet(removedHitPoints, temporaryHitPoints) {
+    return {
+        type: actionTypes.HIT_POINTS_SET,
+        payload: {
+            removedHitPoints,
+            temporaryHitPoints,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.HIT_POINTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param inspiration
+ */
+export function inspirationSet(inspiration) {
+    return {
+        type: actionTypes.INSPIRATION_SET,
+        payload: {
+            inspiration,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.INSPIRATION_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param currencies
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ * @param accept
+ * @param reject
+ */
+export function currenciesSet(currencies, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.CURRENCIES_SET,
+        payload: Object.assign(Object.assign({}, currencies), { destinationEntityTypeId,
+            destinationEntityId }),
+        meta: {
+            commit: {
+                type: actionTypes.CURRENCIES_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function currencyCopperSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.CURRENCY_COPPER_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CURRENCY_COPPER_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function currencyElectrumSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.CURRENCY_ELECTRUM_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CURRENCY_ELECTRUM_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param transactionPayload
+ * @param accept
+ * @param reject
+ */
+export function currencyTransactionSet(transactionPayload, accept, reject) {
+    return {
+        type: actionTypes.CURRENCY_TRANSACTION_SET,
+        payload: Object.assign({}, transactionPayload),
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function currencyGoldSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.CURRENCY_GOLD_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CURRENCY_GOLD_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function currencyPlatinumSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.CURRENCY_PLATINUM_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CURRENCY_PLATINUM_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function currencySilverSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.CURRENCY_SILVER_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CURRENCY_SILVER_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param starting
+ * @param accept
+ * @param reject
+ */
+export function startingEquipmentAddRequest(starting, accept, reject) {
+    return {
+        type: actionTypes.STARTING_EQUIPMENT_ADD_REQUEST,
+        payload: Object.assign({}, starting),
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param gold
+ * @param accept
+ * @param reject
+ */
+export function startingGoldAddRequest(gold, accept, reject) {
+    return {
+        type: actionTypes.STARTING_GOLD_ADD_REQUEST,
+        payload: {
+            gold,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param fails
+ * @param successes
+ */
+export function deathSavesSet(fails, successes) {
+    return {
+        type: actionTypes.DEATHSAVES_SET,
+        payload: {
+            fails,
+            successes,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.DEATHSAVES_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param customSpeed
+ */
+export function movementAdd(customSpeed) {
+    return {
+        type: actionTypes.MOVEMENT_ADD,
+        payload: Object.assign({}, customSpeed),
+        meta: {
+            commit: {
+                type: actionTypes.MOVEMENT_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param customSpeed
+ */
+export function movementSet(customSpeed) {
+    return {
+        type: actionTypes.MOVEMENT_SET,
+        payload: Object.assign({}, customSpeed),
+        meta: {
+            commit: {
+                type: actionTypes.MOVEMENT_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param movementId
+ */
+export function movementRemove(movementId) {
+    return {
+        type: actionTypes.MOVEMENT_REMOVE,
+        payload: {
+            movementId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.MOVEMENT_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param customSense
+ */
+export function senseAdd(customSense) {
+    return {
+        type: actionTypes.SENSE_ADD,
+        payload: Object.assign({}, customSense),
+        meta: {
+            commit: {
+                type: actionTypes.SENSE_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param customSense
+ */
+export function senseSet(customSense) {
+    return {
+        type: actionTypes.SENSE_SET,
+        payload: Object.assign({}, customSense),
+        meta: {
+            commit: {
+                type: actionTypes.SENSE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param senseId
+ */
+export function senseRemove(senseId) {
+    return {
+        type: actionTypes.SENSE_REMOVE,
+        payload: {
+            senseId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.SENSE_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param proficiency
+ */
+export function customProficiencyAdd(proficiency) {
+    return {
+        type: actionTypes.CUSTOM_PROFICIENCY_ADD,
+        payload: {
+            proficiency,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_PROFICIENCY_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function customProficiencyRemove(id) {
+    return {
+        type: actionTypes.CUSTOM_PROFICIENCY_REMOVE,
+        payload: {
+            id,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_PROFICIENCY_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param properties
+ */
+export function customProficiencySet(id, properties) {
+    return {
+        type: actionTypes.CUSTOM_PROFICIENCY_SET,
+        payload: {
+            id,
+            properties,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_PROFICIENCY_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param customDefenseAdjustment
+ */
+export function customDefenseAdjustmentAdd(customDefenseAdjustment) {
+    return {
+        type: actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_ADD,
+        payload: Object.assign({}, customDefenseAdjustment),
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param customDefenseAdjustment
+ */
+export function customDefenseAdjustmentSet(customDefenseAdjustment) {
+    return {
+        type: actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_SET,
+        payload: Object.assign({}, customDefenseAdjustment),
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param type
+ * @param adjustmentId
+ */
+export function customDefenseAdjustmentRemove(type, adjustmentId) {
+    return {
+        type: actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_REMOVE,
+        payload: {
+            type,
+            adjustmentId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_DEFENSE_ADJUSTMENT_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param statId
+ * @param value
+ */
+export function abilityScoreBonusSet(statId, value) {
+    return {
+        type: actionTypes.ABILITY_SCORE_BONUS_SET,
+        payload: {
+            statId,
+            value,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ABILITY_SCORE_BONUS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param statId
+ * @param value
+ */
+export function abilityScoreOverrideSet(statId, value) {
+    return {
+        type: actionTypes.ABILITY_SCORE_OVERRIDE_SET,
+        payload: {
+            statId,
+            value,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ABILITY_SCORE_OVERRIDE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param statId
+ * @param value
+ */
+export function abilityScoreBaseSet(statId, value) {
+    return {
+        type: actionTypes.ABILITY_SCORE_BASE_SET,
+        payload: {
+            statId,
+            value,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ABILITY_SCORE_BASE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param status
+ */
+export function statusSet(status) {
+    return {
+        type: actionTypes.STATUS_SET,
+        payload: {
+            status,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.STATUS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param statusSlug
+ */
+export function statusSlugSet(statusSlug) {
+    return {
+        type: actionTypes.STATUS_SLUG_SET,
+        payload: {
+            statusSlug,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.STATUS_SLUG_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/choice.js

@@ -0,0 +1,22 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param {array} choices
+ * @param {array} choices.background
+ * @param {array} choices.class
+ * @param {array} choices.feat
+ * @param {array} choices.race
+ */
+export function choicesSet(choices) {
+    return {
+        type: actionTypes.CHOICES_SET,
+        payload: {
+            choices,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CHOICES_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/class.js

@@ -0,0 +1,104 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param charClass
+ * @param level
+ */
+export function classAddRequest(charClass, level) {
+    return {
+        type: actionTypes.CLASS_ADD_REQUEST,
+        payload: {
+            charClass,
+            level,
+        },
+        meta: {
+            postAction: {
+                type: [actionTypes.CLASS_ADD_POST_ACTION],
+            },
+        },
+    };
+}
+/**
+ *
+ * @param characterClassId
+ * @param newCharacterXp
+ */
+export function classRemoveRequest(characterClassId, newCharacterXp = null) {
+    return {
+        type: actionTypes.CLASS_REMOVE_REQUEST,
+        payload: {
+            characterClassId,
+            newCharacterXp,
+        },
+        meta: {
+            postAction: {
+                type: [actionTypes.CLASS_REMOVE_POST_ACTION],
+            },
+        },
+    };
+}
+/**
+ *
+ * @param classId
+ * @param level
+ * @param newCharacterXp
+ */
+export function classLevelSetRequest(classId, level, newCharacterXp = null) {
+    return {
+        type: actionTypes.CLASS_LEVEL_SET_REQUEST,
+        payload: {
+            classId,
+            level,
+            newCharacterXp,
+        },
+        meta: {},
+    };
+}
+// TODO needs commit workflow
+/**
+ *
+ * @param charClass
+ */
+export function classAdd(charClass) {
+    return {
+        type: actionTypes.CLASS_ADD,
+        payload: {
+            charClass,
+        },
+        meta: {},
+    };
+}
+// TODO needs commit workflow
+/**
+ *
+ * @param classes
+ */
+export function classesSet(classes) {
+    return {
+        type: actionTypes.CLASSES_SET,
+        payload: {
+            classes,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CLASSES_SET_COMMIT,
+            },
+        },
+    };
+}
+// TODO needs commit workflow
+/**
+ *
+ * @param charClass
+ */
+export function classSet(charClass) {
+    return {
+        type: actionTypes.CLASS_SET,
+        payload: Object.assign({}, charClass),
+        meta: {
+            commit: {
+                type: actionTypes.CLASS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/classFeature.js

@@ -0,0 +1,23 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param classId
+ * @param classFeatureId
+ * @param choiceType
+ * @param choiceId
+ * @param optionValue
+ */
+export function classFeatureChoiceSetRequest(classId, classFeatureId, choiceType, choiceId, optionValue, parentChoiceId) {
+    return {
+        type: actionTypes.CLASS_FEATURE_CHOICE_SET_REQUEST,
+        payload: {
+            classId,
+            classFeatureId,
+            choiceType,
+            choiceId,
+            optionValue,
+            parentChoiceId,
+        },
+        meta: {},
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/condition.js

@@ -0,0 +1,61 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param id
+ * @param level
+ */
+export function conditionSet(id, level = null) {
+    return {
+        type: actionTypes.CONDITION_SET,
+        payload: {
+            id,
+            level,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param id
+ * @param level
+ */
+export function conditionAdd(id, level = null) {
+    return {
+        type: actionTypes.CONDITION_ADD,
+        payload: {
+            id,
+            level,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function conditionRemove(id) {
+    return {
+        type: actionTypes.CONDITION_REMOVE,
+        payload: {
+            id,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param conditions
+ */
+export function conditionsSet(conditions) {
+    return {
+        type: actionTypes.CONDITIONS_SET,
+        payload: {
+            conditions,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CONDITIONS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/configuration.js

@@ -0,0 +1,77 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param showHelpText
+ */
+export function showHelpTextSet(showHelpText) {
+    return {
+        type: actionTypes.SHOW_HELP_TEXT_SET,
+        payload: {
+            showHelpText,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param showHelpText
+ */
+export function showHelpTextSetRequest(showHelpText) {
+    return {
+        type: actionTypes.SHOW_HELP_TEXT_SET_REQUEST,
+        payload: {
+            showHelpText,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param startingEquipmentType
+ */
+export function startingEquipmentTypeSet(startingEquipmentType) {
+    return {
+        type: actionTypes.STARTING_EQUIPMENT_TYPE_SET,
+        payload: {
+            startingEquipmentType,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param payload
+ */
+export function startingEquipmentTypeSetCommit(payload) {
+    return {
+        type: actionTypes.STARTING_EQUIPMENT_TYPE_SET_COMMIT,
+        payload,
+        meta: {},
+    };
+}
+/**
+ *
+ * @param abilityScoreType
+ */
+export function abilityScoreTypeSetRequest(abilityScoreType) {
+    return {
+        type: actionTypes.ABILITY_SCORE_TYPE_SET_REQUEST,
+        payload: {
+            abilityScoreType,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param abilityScoreType
+ */
+export function abilityScoreTypeSetCommit(abilityScoreType) {
+    return {
+        type: actionTypes.ABILITY_SCORE_TYPE_SET_COMMIT,
+        payload: {
+            abilityScoreType,
+        },
+        meta: {},
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/core.js

@@ -0,0 +1,103 @@
+import * as actionTypes from '../actionTypes';
+// TODO needs commit flow
+/**
+ *
+ * @param data
+ */
+export function characterSet(data) {
+    return {
+        type: actionTypes.CHARACTER_SET,
+        payload: Object.assign({}, data),
+        meta: {},
+    };
+}
+/**
+ *
+ * @param activeSourceCategories
+ */
+export function activeSourceCategoriesSet(activeSourceCategories) {
+    return {
+        type: actionTypes.ACTIVE_SOURCE_CATEGORIES_SET,
+        payload: {
+            activeSourceCategories,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ACTIVE_SOURCE_CATEGORIES_SET_COMMIT,
+            },
+        },
+    };
+}
+export function activeSourcesSet(enabledSourceIds, campaignSettingId) {
+    return {
+        type: actionTypes.ACTIVE_SOURCES_SET,
+        payload: {
+            enabledSourceIds,
+            campaignSettingId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ACTIVE_SOURCES_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param key
+ * @param value
+ */
+export function preferenceChoose(key, value) {
+    return {
+        type: actionTypes.PREFERENCE_CHOOSE,
+        payload: {
+            key,
+            value,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param key
+ * @param value
+ */
+export function preferenceSet(key, value) {
+    return {
+        type: actionTypes.PREFERENCE_SET,
+        payload: {
+            [key]: value,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PREFERENCE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param components
+ */
+export function characterComponentsSet(components) {
+    return {
+        type: actionTypes.CHARACTER_COMPONENTS_SET,
+        payload: Object.assign({}, components),
+        meta: {
+            commit: {
+                type: actionTypes.CHARACTER_COMPONENTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param socialImageData
+ */
+export function SendSocialImageData() {
+    return {
+        type: actionTypes.SEND_SOCIAL_IMAGE_DATA,
+        payload: {},
+        meta: {},
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/creature.js

@@ -0,0 +1,131 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param groupId
+ * @param monsterId
+ * @param names
+ * @param accept
+ * @param reject
+ */
+export function creatureCreate(groupId, monsterId, names, accept, reject) {
+    return {
+        type: actionTypes.CREATURE_CREATE,
+        payload: {
+            groupId,
+            monsterId,
+            names,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param creature
+ */
+export function creatureAdd(creature) {
+    return {
+        type: actionTypes.CREATURE_ADD,
+        payload: {
+            creature,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CREATURE_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function creatureRemove(id) {
+    return {
+        type: actionTypes.CREATURE_REMOVE,
+        payload: {
+            id,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CREATURE_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param properties
+ */
+export function creatureDataSet(id, properties) {
+    return {
+        type: actionTypes.CREATURE_DATA_SET,
+        payload: {
+            id,
+            properties,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CREATURE_DATA_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param removedHitPoints
+ * @param temporaryHitPoints
+ */
+export function creatureHitPointsSet(id, removedHitPoints, temporaryHitPoints) {
+    return {
+        type: actionTypes.CREATURE_HIT_POINTS_SET,
+        payload: {
+            id,
+            removedHitPoints,
+            temporaryHitPoints,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CREATURE_HIT_POINTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param isActive
+ */
+export function creatureActiveSet(id, isActive) {
+    return {
+        type: actionTypes.CREATURE_ACTIVE_SET,
+        payload: {
+            id,
+            isActive,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CREATURE_ACTIVE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param mappingId
+ * @param mappingEntityTypeId
+ */
+export function creatureCustomizationsDelete(mappingId, mappingEntityTypeId) {
+    return {
+        type: actionTypes.CREATURE_CUSTOMIZATIONS_DELETE,
+        payload: {
+            mappingId,
+            mappingEntityTypeId,
+        },
+        meta: {},
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/decoration.js

@@ -0,0 +1,84 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param backdrop
+ */
+export function backdropSet(backdrop) {
+    return {
+        type: actionTypes.BACKDROP_SET,
+        payload: {
+            backdrop,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.BACKDROP_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param frame
+ */
+export function frameSet(frame) {
+    return {
+        type: actionTypes.FRAME_SET,
+        payload: {
+            frame,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.FRAME_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param themeColor
+ */
+export function themeSet(themeColor) {
+    return {
+        type: actionTypes.THEME_SET,
+        payload: {
+            themeColor,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.THEME_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param avatarId
+ * @param avatarUrl
+ */
+export function portraitSet(avatarId, avatarUrl) {
+    return {
+        type: actionTypes.PORTRAIT_SET,
+        payload: {
+            avatarId,
+            avatarUrl,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PORTRAIT_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param avatarImage
+ */
+export function portraitUpload(avatarImage) {
+    return {
+        type: actionTypes.PORTRAIT_UPLOAD,
+        payload: {
+            avatarImage,
+        },
+        meta: {},
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/feat.js

@@ -0,0 +1,80 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param feats
+ */
+export function featsSet(feats) {
+    return {
+        type: actionTypes.FEATS_SET,
+        payload: {
+            feats,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.FEATS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param featId
+ * @param choiceType
+ * @param choiceId
+ * @param optionValue
+ */
+export function featChoiceSetRequest(featId, choiceType, choiceId, optionValue) {
+    return {
+        type: actionTypes.FEAT_CHOICE_SET_REQUEST,
+        payload: {
+            featId,
+            choiceType,
+            choiceId,
+            optionValue,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function adhocFeatCreate(id) {
+    return {
+        type: actionTypes.ADHOC_FEAT_CREATE,
+        payload: {
+            id,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function adhocFeatRemove(id) {
+    return {
+        type: actionTypes.ADHOC_FEAT_REMOVE,
+        payload: {
+            id,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param id
+ * @param featureId
+ * @param featureTypeId
+ */
+export function setEntityFeat(id, featureId, featureTypeId) {
+    return {
+        type: actionTypes.SET_ENTITY_FEAT,
+        payload: {
+            id,
+            featureId,
+            featureTypeId,
+        },
+        meta: {}, // TODO consider passing accept and reject callbacks into meta
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/item.js

@@ -0,0 +1,460 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param item
+ * @param quantity
+ * @param accept
+ * @param reject
+ * @param containerDefinitionKey
+ */
+export function itemCreate(item, quantity, accept, reject, containerDefinitionKey) {
+    return {
+        type: actionTypes.ITEM_CREATE,
+        payload: {
+            item,
+            quantity,
+            containerDefinitionKey,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param name
+ * @param description
+ * @param cost
+ * @param quantity
+ * @param weight
+ * @param notes
+ * @param containerDefinitionKey
+ * @param partyId
+ * @param accept
+ * @param reject
+ */
+export function customItemCreate(name, description = null, cost = null, quantity = null, weight = null, notes = null, containerDefinitionKey, partyId = null, accept, reject) {
+    return {
+        type: actionTypes.CUSTOM_ITEM_CREATE,
+        payload: {
+            name,
+            description,
+            cost,
+            quantity,
+            weight,
+            notes,
+            containerDefinitionKey,
+            partyId,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param mappingId
+ * @param partyId
+ * @param accept
+ * @param reject
+ */
+export function customItemDestroy(id, mappingId, partyId = null, accept, reject) {
+    return {
+        type: actionTypes.CUSTOM_ITEM_DESTROY,
+        payload: {
+            id,
+            mappingId,
+            partyId,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param item
+ */
+export function customItemAdd(item) {
+    return {
+        type: actionTypes.CUSTOM_ITEM_ADD,
+        payload: {
+            item,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_ITEM_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function customItemRemove(id) {
+    return {
+        type: actionTypes.CUSTOM_ITEM_REMOVE,
+        payload: {
+            id,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_ITEM_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param properties
+ * @param mappingId
+ * @param partyId
+ * @param accept
+ * @param reject
+ */
+export function customItemSet(id, properties, mappingId, partyId = null, accept, reject) {
+    return {
+        type: actionTypes.CUSTOM_ITEM_SET,
+        payload: {
+            id,
+            properties,
+            mappingId,
+            partyId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CUSTOM_ITEM_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param item
+ */
+export function itemAdd(item) {
+    return {
+        type: actionTypes.ITEM_ADD,
+        payload: {
+            item,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param removeContainerContents
+ */
+export function itemRemove(id, removeContainerContents) {
+    return {
+        type: actionTypes.ITEM_REMOVE,
+        payload: {
+            id,
+            removeContainerContents,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param removeContainerContents
+ */
+export function itemDestroy(id, removeContainerContents, accept, reject) {
+    return {
+        type: actionTypes.ITEM_DESTROY,
+        payload: {
+            id,
+            removeContainerContents,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param value
+ */
+export function itemEquippedSet(id, value, equippedEntityId, equippedEntityTypeId, accept, reject) {
+    return {
+        type: actionTypes.ITEM_EQUIPPED_SET,
+        payload: {
+            id,
+            value,
+            equippedEntityId,
+            equippedEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_EQUIPPED_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param value
+ * @param accept
+ * @param reject
+ */
+export function itemAttuneSet(id, value, accept, reject) {
+    return {
+        type: actionTypes.ITEM_ATTUNE_SET,
+        payload: {
+            id,
+            value,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_ATTUNE_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param containerEntityId
+ * @param containerEntityTypeId
+ * @param accept
+ * @param reject
+ */
+export function itemMoveSet(id, containerEntityId, containerEntityTypeId, accept, reject) {
+    return {
+        type: actionTypes.ITEM_MOVE_SET,
+        payload: {
+            id,
+            containerEntityId,
+            containerEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_MOVE_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param quantity
+ * @param containerEntityId
+ * @param containerEntityTypeId
+ */
+export function itemQuantitySet(id, quantity, accept, reject) {
+    return {
+        type: actionTypes.ITEM_QUANTITY_SET,
+        payload: {
+            id,
+            quantity,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_QUANTITY_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param uses
+ * @param accept
+ * @param reject
+ */
+export function itemChargesSet(id, uses, accept, reject) {
+    return {
+        type: actionTypes.ITEM_CHARGES_SET,
+        payload: {
+            id,
+            uses,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_CHARGES_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param mappingId
+ * @param mappingEntityTypeId
+ * @param partyId
+ * @param accept
+ * @param reject
+ */
+export function itemCustomizationsDelete(mappingId, mappingEntityTypeId, partyId, accept, reject) {
+    return {
+        type: actionTypes.ITEM_CUSTOMIZATIONS_DELETE,
+        payload: {
+            mappingId,
+            mappingEntityTypeId,
+            partyId,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param currencies
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ * @param accept
+ * @param reject
+ */
+export function itemCurrencySet(currency, id, accept, reject) {
+    return {
+        type: actionTypes.ITEM_CURRENCY_SET,
+        payload: {
+            currency,
+            id,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_CURRENCY_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function itemCurrencyCopperSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.ITEM_CURRENCY_COPPER_SET,
+        payload: {
+            amount,
+            destinationEntityTypeId,
+            destinationEntityId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_CURRENCY_COPPER_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function itemCurrencySilverSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.ITEM_CURRENCY_SILVER_SET,
+        payload: {
+            amount,
+            destinationEntityTypeId,
+            destinationEntityId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_CURRENCY_SILVER_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function itemCurrencyElectrumSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.ITEM_CURRENCY_ELECTRUM_SET,
+        payload: {
+            amount,
+            destinationEntityTypeId,
+            destinationEntityId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_CURRENCY_ELECTRUM_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function itemCurrencyGoldSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.ITEM_CURRENCY_GOLD_SET,
+        payload: {
+            amount,
+            destinationEntityTypeId,
+            destinationEntityId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_CURRENCY_GOLD_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function itemCurrencyPlatinumSet(amount, destinationEntityTypeId, destinationEntityId) {
+    return {
+        type: actionTypes.ITEM_CURRENCY_PLATINUM_SET,
+        payload: {
+            amount,
+            destinationEntityTypeId,
+            destinationEntityId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ITEM_CURRENCY_PLATINUM_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/modifier.js

@@ -0,0 +1,18 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param modifiers
+ */
+export function modifiersSet(modifiers) {
+    return {
+        type: actionTypes.MODIFIERS_SET,
+        payload: {
+            modifiers,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.MODIFIERS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/option.js

@@ -0,0 +1,18 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param options
+ */
+export function optionsSet(options) {
+    return {
+        type: actionTypes.OPTIONS_SET,
+        payload: {
+            options,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.OPTIONS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/optionalClassFeature.js

@@ -0,0 +1,93 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param classFeatureId
+ * @param affectedClassFeatureId
+ */
+export function optionalClassFeatureCreate(classFeatureId, affectedClassFeatureId) {
+    return {
+        type: actionTypes.OPTIONAL_CLASS_FEATURE_CREATE,
+        payload: {
+            classFeatureId,
+            affectedClassFeatureId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param optionalClassFeature
+ */
+export function optionalClassFeatureAdd(optionalClassFeature) {
+    return {
+        type: actionTypes.OPTIONAL_CLASS_FEATURE_ADD,
+        payload: {
+            optionalClassFeature,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.OPTIONAL_CLASS_FEATURE_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param classFeatureId
+ * @param affectedClassFeatureId
+ */
+export function optionalClassFeatureSetRequest(classFeatureId, affectedClassFeatureId) {
+    return {
+        type: actionTypes.OPTIONAL_CLASS_FEATURE_SET_REQUEST,
+        payload: {
+            classFeatureId,
+            affectedClassFeatureId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param optionalClassFeatureProps
+ */
+export function optionalClassFeatureSet(optionalClassFeatureProps) {
+    return {
+        type: actionTypes.OPTIONAL_CLASS_FEATURE_SET,
+        payload: Object.assign({}, optionalClassFeatureProps),
+        meta: {
+            commit: {
+                type: actionTypes.OPTIONAL_CLASS_FEATURE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param classFeatureId
+ */
+export function optionalClassFeatureDestroy(classFeatureId) {
+    return {
+        type: actionTypes.OPTIONAL_CLASS_FEATURE_DESTROY,
+        payload: {
+            classFeatureId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param classFeatureId
+ */
+export function optionalClassFeatureRemove(classFeatureId) {
+    return {
+        type: actionTypes.OPTIONAL_CLASS_FEATURE_REMOVE,
+        payload: {
+            classFeatureId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.OPTIONAL_CLASS_FEATURE_REMOVE_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/optionalOrigin.js

@@ -0,0 +1,93 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param racialTraitId
+ * @param affectedRacialTraitId
+ */
+export function optionalOriginCreate(racialTraitId, affectedRacialTraitId) {
+    return {
+        type: actionTypes.OPTIONAL_ORIGIN_CREATE,
+        payload: {
+            racialTraitId,
+            affectedRacialTraitId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param optionalOrigin
+ */
+export function optionalOriginAdd(optionalOrigin) {
+    return {
+        type: actionTypes.OPTIONAL_ORIGIN_ADD,
+        payload: {
+            optionalOrigin,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.OPTIONAL_ORIGIN_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param racialTraitId
+ * @param affectedRacialTraitId
+ */
+export function optionalOriginSetRequest(racialTraitId, affectedRacialTraitId) {
+    return {
+        type: actionTypes.OPTIONAL_ORIGIN_SET_REQUEST,
+        payload: {
+            racialTraitId,
+            affectedRacialTraitId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param optionalOriginContract
+ */
+export function optionalOriginSet(optionalOriginContract) {
+    return {
+        type: actionTypes.OPTIONAL_ORIGIN_SET,
+        payload: Object.assign({}, optionalOriginContract),
+        meta: {
+            commit: {
+                type: actionTypes.OPTIONAL_ORIGIN_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param racialTraitId
+ */
+export function optionalOriginDestroy(racialTraitId) {
+    return {
+        type: actionTypes.OPTIONAL_ORIGIN_DESTROY,
+        payload: {
+            racialTraitId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param racialTraitId
+ */
+export function optionalOriginRemove(racialTraitId) {
+    return {
+        type: actionTypes.OPTIONAL_ORIGIN_REMOVE,
+        payload: {
+            racialTraitId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.OPTIONAL_ORIGIN_REMOVE_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/premadeInfo.js

@@ -0,0 +1,56 @@
+import * as actionTypes from '../actionTypes';
+export function premadeInfoSetCommit(premadeInfo) {
+    return {
+        type: actionTypes.PREMADE_INFO_SET_COMMIT,
+        payload: premadeInfo,
+        meta: {},
+    };
+}
+export function premadeInfoAdd(premadeInfo) {
+    return {
+        type: actionTypes.PREMADE_INFO_ADD,
+        payload: premadeInfo,
+        meta: {
+            commit: {
+                type: actionTypes.PREMADE_INFO_SET_COMMIT,
+            },
+        },
+    };
+}
+export function premadeInfoGet(characterId) {
+    return {
+        type: actionTypes.PREMADE_INFO_GET,
+        payload: {
+            characterId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PREMADE_INFO_SET_COMMIT,
+            },
+        },
+    };
+}
+export function premadeInfoUpdate(premadeInfo) {
+    return {
+        type: actionTypes.PREMADE_INFO_UPDATE,
+        payload: premadeInfo,
+        meta: {
+            commit: {
+                type: actionTypes.PREMADE_INFO_SET_COMMIT,
+            },
+        },
+    };
+}
+export function premadeInfoDelete(characterId) {
+    return {
+        type: actionTypes.PREMADE_INFO_DELETE,
+        payload: {
+            characterId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PREMADE_INFO_REMOVE_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/race.js

@@ -0,0 +1,35 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param race
+ */
+export function raceChoose(race) {
+    return {
+        type: actionTypes.RACE_CHOOSE,
+        payload: {
+            race,
+        },
+        meta: {
+            postAction: {
+                type: [actionTypes.RACE_CHOOSE_POST_ACTION],
+            },
+        },
+    };
+}
+/**
+ *
+ * @param race
+ */
+export function raceSet(race) {
+    return {
+        type: actionTypes.RACE_SET,
+        payload: {
+            race,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.RACE_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/racialTrait.js

@@ -0,0 +1,20 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param racialTraitId
+ * @param choiceType
+ * @param choiceId
+ * @param optionValue
+ */
+export function racialTraitChoiceSetRequest(racialTraitId, choiceType, choiceId, optionValue) {
+    return {
+        type: actionTypes.RACIAL_TRAIT_CHOICE_SET_REQUEST,
+        payload: {
+            racialTraitId,
+            choiceType,
+            choiceId,
+            optionValue,
+        },
+        meta: {},
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/spell.js

@@ -0,0 +1,213 @@
+import { SpellAccessors } from '../../../engine/Spell';
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param spell
+ * @param characterClassId
+ * @param accept
+ * @param reject
+ */
+export function spellCreate(spell, characterClassId, accept, reject) {
+    return {
+        type: actionTypes.SPELL_CREATE,
+        payload: {
+            spell,
+            characterClassId,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param spell
+ * @param characterClassId
+ */
+export function spellAdd(spell, characterClassId) {
+    return {
+        type: actionTypes.SPELL_ADD,
+        payload: {
+            spell,
+            characterClassId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.SPELL_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param spell
+ * @param characterClassId
+ * @param prepared
+ */
+export function spellPreparedSet(spell, characterClassId, prepared, accept, reject) {
+    return {
+        type: actionTypes.SPELL_PREPARED_SET,
+        payload: {
+            spellId: SpellAccessors.getId(spell),
+            characterClassId,
+            entityTypeId: SpellAccessors.getMappingEntityTypeId(spell),
+            id: SpellAccessors.getMappingId(spell),
+            prepared,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.SPELL_PREPARED_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param spell
+ * @param characterClassId
+ */
+export function spellRemove(spell, characterClassId, accept, reject) {
+    const payload = {
+        spellId: SpellAccessors.getId(spell),
+        characterClassId,
+        entityTypeId: SpellAccessors.getMappingEntityTypeId(spell),
+        id: SpellAccessors.getMappingId(spell),
+    };
+    return {
+        type: actionTypes.SPELL_REMOVE,
+        payload: Object.assign(Object.assign({}, payload), { spell }),
+        meta: {
+            commit: {
+                type: actionTypes.SPELL_REMOVE_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param entityTypeId
+ * @param uses
+ * @param dataOriginType
+ */
+export function spellUseSet(id, entityTypeId, uses, dataOriginType) {
+    return {
+        type: actionTypes.SPELL_USE_SET,
+        payload: {
+            id,
+            entityTypeId,
+            uses,
+            dataOriginType,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.SPELL_USE_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param pactMagic
+ */
+export function pactMagicSet(pactMagic) {
+    return {
+        type: actionTypes.PACT_MAGIC_SET,
+        payload: {
+            pactMagic,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PACT_MAGIC_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param spellSlots
+ */
+export function spellSlotsSet(spellSlots) {
+    return {
+        type: actionTypes.SPELLS_SLOTS_SET,
+        payload: {
+            spellSlots,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.SPELLS_SLOTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param levels
+ */
+export function spellLevelSpellSlotsSet(levels) {
+    return {
+        type: actionTypes.SPELL_LEVEL_SPELL_SLOTS_SET,
+        payload: levels,
+        meta: {
+            commit: {
+                type: actionTypes.SPELL_LEVEL_SPELL_SLOTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param levels
+ */
+export function spellLevelPactMagicSlotsSet(levels) {
+    return {
+        type: actionTypes.SPELL_LEVEL_PACT_MAGIC_SLOTS_SET,
+        payload: levels,
+        meta: {
+            commit: {
+                type: actionTypes.SPELL_LEVEL_PACT_MAGIC_SLOTS_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param mappingId
+ * @param mappingEntityTypeId
+ * @param contextId
+ * @param contextTypeId
+ */
+export function spellCustomizationsDelete(mappingId, mappingEntityTypeId, contextId = null, contextTypeId = null) {
+    return {
+        type: actionTypes.SPELL_CUSTOMIZATIONS_DELETE,
+        payload: {
+            mappingId,
+            mappingEntityTypeId,
+            contextId,
+            contextTypeId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param spells
+ */
+export function characterSpellsSet(spells) {
+    return {
+        type: actionTypes.CHARACTER_SPELLS_SET,
+        payload: {
+            spells,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CHARACTER_SPELLS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/actions/value.js

@@ -0,0 +1,87 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param typeId
+ * @param value
+ * @param notes
+ * @param valueId
+ * @param valueTypeId
+ * @param contextId
+ * @param contextTypeId
+ * @param partyId
+ * @param accept
+ * @param reject
+ */
+export function valueSet(typeId, value, notes, valueId = null, valueTypeId = null, contextId = null, contextTypeId = null, partyId = null, accept, reject) {
+    return {
+        type: actionTypes.VALUE_SET,
+        payload: {
+            typeId,
+            value,
+            notes,
+            valueId,
+            valueTypeId,
+            contextId,
+            contextTypeId,
+            partyId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VALUE_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ * @param typeId
+ * @param valueId
+ * @param valueTypeId
+ * @param contextId
+ * @param contextTypeId
+ * @param partyId
+ */
+export function valueRemove(typeId, valueId = null, valueTypeId = null, contextId = null, contextTypeId = null, partyId = null) {
+    return {
+        type: actionTypes.VALUE_REMOVE,
+        payload: {
+            typeId,
+            valueId,
+            valueTypeId,
+            contextId,
+            contextTypeId,
+            partyId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VALUE_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param valueId
+ * @param valueTypeId
+ * @param contextId
+ * @param contextTypeId
+ * @param partyId
+ */
+export function entityValuesRemove(valueId = null, valueTypeId = null, contextId = null, contextTypeId = null, partyId = null) {
+    return {
+        type: actionTypes.ENTITY_VALUES_REMOVE,
+        payload: {
+            valueId,
+            valueTypeId,
+            contextId,
+            contextTypeId,
+            partyId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.ENTITY_VALUES_REMOVE_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/character/index.js

@@ -0,0 +1,6 @@
+import * as actionTypes from './actionTypes';
+import * as actions from './actions';
+import * as typings from './typings';
+export const characterActionTypes = actionTypes;
+export const characterActions = actions;
+export const characterTypings = typings;

ddb_main/packages/rules-engine/es/actions/characterEnv/actionTypes.js

@@ -0,0 +1 @@
+export const DATA_SET = 'characterEnv.DATA_SET';

ddb_main/packages/rules-engine/es/actions/characterEnv/actions.js

@@ -0,0 +1,11 @@
+import * as actionTypes from './actionTypes';
+/**
+ *
+ * @param payload
+ */
+export function dataSet(payload) {
+    return {
+        type: actionTypes.DATA_SET,
+        payload,
+    };
+}

ddb_main/packages/rules-engine/es/actions/characterEnv/index.js

@@ -0,0 +1,6 @@
+import * as actionTypes from './actionTypes';
+import * as actions from './actions';
+import * as typings from './typings';
+export const characterEnvActionTypes = actionTypes;
+export const characterEnvActions = actions;
+export const characterEnvTypings = typings;

ddb_main/packages/rules-engine/es/actions/featureFlagInfo/actionTypes.js

@@ -0,0 +1 @@
+export const DATA_SET = 'featureFlagInfo.DATA_SET';

ddb_main/packages/rules-engine/es/actions/featureFlagInfo/actions.js

@@ -0,0 +1,11 @@
+import * as actionTypes from './actionTypes';
+/**
+ *
+ * @param featureFlags
+ */
+export function dataSet(data) {
+    return {
+        type: actionTypes.DATA_SET,
+        payload: data,
+    };
+}

ddb_main/packages/rules-engine/es/actions/featureFlagInfo/index.js

@@ -0,0 +1,6 @@
+import * as actionTypes from './actionTypes';
+import * as actions from './actions';
+import * as typings from './typings';
+export const featureFlagInfoActionTypes = actionTypes;
+export const featureFlagInfoActions = actions;
+export const featureFlagInfoTypings = typings;

ddb_main/packages/rules-engine/es/actions/ruleData/actionTypes.js

@@ -0,0 +1 @@
+export const DATA_SET = 'ruleData.DATA_SET';

ddb_main/packages/rules-engine/es/actions/ruleData/actions.js

@@ -0,0 +1,11 @@
+import * as actionTypes from './actionTypes';
+/**
+ *
+ * @param payload
+ */
+export function dataSet(payload) {
+    return {
+        type: actionTypes.DATA_SET,
+        payload,
+    };
+}

ddb_main/packages/rules-engine/es/actions/ruleData/index.js

@@ -0,0 +1,6 @@
+import * as actionTypes from './actionTypes';
+import * as actions from './actions';
+import * as typings from './typings';
+export const ruleDataActionTypes = actionTypes;
+export const ruleDataActions = actions;
+export const ruleDataTypings = typings;

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/campaign.js

@@ -0,0 +1,41 @@
+export const PARTY_ITEM_ADD = 'campaign.PARTY_ITEM_ADD';
+export const PARTY_ITEM_ADD_COMMIT = 'campaign.PARTY_ITEM_ADD_COMMIT';
+export const PARTY_ITEM_MOVE_SET = 'campaign.PARTY_ITEM_MOVE_SET';
+export const PARTY_ITEM_MOVE_SET_COMMIT = 'campaign.PARTY_ITEM_MOVE_SET_COMMIT';
+export const PARTY_ITEM_EQUIPPED_SET = 'campaign.PARTY_ITEM_EQUIPPED_SET';
+export const PARTY_ITEM_EQUIPPED_SET_COMMIT = 'campaign.PARTY_ITEM_EQUIPPED_SET_COMMIT';
+export const PARTY_ITEM_ATTUNE_SET = 'campaign.PARTY_ITEM_ATTUNE_SET';
+export const PARTY_ITEM_ATTUNE_SET_COMMIT = 'campaign.PARTY_ITEM_ATTUNE_SET_COMMIT';
+export const PARTY_ITEM_QUANTITY_SET = 'campaign.PARTY_ITEM_QUANTITY_SET';
+export const PARTY_ITEM_QUANTITY_SET_COMMIT = 'campaign.PARTY_ITEM_QUANTITY_SET_COMMIT';
+export const PARTY_ITEM_REMOVE = 'campaign.PARTY_ITEM_REMOVE';
+export const PARTY_ITEM_REMOVE_COMMIT = 'campaign.PARTY_ITEM_REMOVE_COMMIT';
+export const PARTY_ITEM_CHARGES_SET = 'campaign.PARTY_ITEM_CHARGES_SET';
+export const PARTY_ITEM_CHARGES_SET_COMMIT = 'campaign.PARTY_ITEM_CHARGES_SET_COMMIT';
+export const PARTY_CAMPAIGN_INFO_SET = 'campaign.PARTY_CAMPAIGN_INFO_SET';
+export const PARTY_INVENTORY_REQUEST = 'campaign.PARTY_INVENTORY_REQUEST';
+export const PARTY_CURRENCY_TRANSACTION_SET = 'campaign.PARTY_CURRENCY_TRANSACTION_SET';
+export const PARTY_CURRENCIES_SET = 'campaign.PARTY_CURRENCIES_SET';
+export const PARTY_CURRENCIES_SET_COMMIT = 'campaign.PARTY_CURRENCIES_SET_COMMIT';
+export const PARTY_CURRENCY_COPPER_SET = 'campaign.PARTY_CURRENCY_COPPER_SET';
+export const PARTY_CURRENCY_COPPER_SET_COMMIT = 'campaign.PARTY_CURRENCY_COPPER_SET_COMMIT';
+export const PARTY_CURRENCY_ELECTRUM_SET = 'campaign.PARTY_CURRENCY_ELECTRUM_SET';
+export const PARTY_CURRENCY_ELECTRUM_SET_COMMIT = 'campaign.PARTY_CURRENCY_ELECTRUM_SET_COMMIT';
+export const PARTY_CURRENCY_GOLD_SET = 'campaign.PARTY_CURRENCY_GOLD_SET';
+export const PARTY_CURRENCY_GOLD_SET_COMMIT = 'campaign.PARTY_CURRENCY_GOLD_SET_COMMIT';
+export const PARTY_CURRENCY_PLATINUM_SET = 'campaign.PARTY_CURRENCY_PLATINUM_SET';
+export const PARTY_CURRENCY_PLATINUM_SET_COMMIT = 'campaign.PARTY_CURRENCY_PLATINUM_SET_COMMIT';
+export const PARTY_CURRENCY_SILVER_SET = 'campaign.PARTY_CURRENCY_SILVER_SET';
+export const PARTY_CURRENCY_SILVER_SET_COMMIT = 'campaign.PARTY_CURRENCY_SILVER_SET_COMMIT';
+export const PARTY_ITEM_CURRENCY_SET = 'campaign.PARTY_ITEM_CURRENCY_SET';
+export const PARTY_ITEM_CURRENCY_SET_COMMIT = 'campaign.PARTY_ITEM_CURRENCY_SET_COMMIT';
+export const PARTY_ITEM_CURRENCY_COPPER_SET = 'campaign.PARTY_ITEM_CURRENCY_COPPER_SET';
+export const PARTY_ITEM_CURRENCY_COPPER_SET_COMMIT = 'campaign.PARTY_ITEM_CURRENCY_COPPER_SET_COMMIT';
+export const PARTY_ITEM_CURRENCY_ELECTRUM_SET = 'campaign.PARTY_ITEM_CURRENCY_ELECTRUM_SET';
+export const PARTY_ITEM_CURRENCY_ELECTRUM_SET_COMMIT = 'campaign.PARTY_ITEM_CURRENCY_ELECTRUM_SET_COMMIT';
+export const PARTY_ITEM_CURRENCY_GOLD_SET = 'campaign.PARTY_ITEM_CURRENCY_GOLD_SET';
+export const PARTY_ITEM_CURRENCY_GOLD_SET_COMMIT = 'campaign.PARTY_ITEM_CURRENCY_GOLD_SET_COMMIT';
+export const PARTY_ITEM_CURRENCY_PLATINUM_SET = 'campaign.PARTY_ITEM_CURRENCY_PLATINUM_SET';
+export const PARTY_ITEM_CURRENCY_PLATINUM_SET_COMMIT = 'campaign.PARTY_ITEM_CURRENCY_PLATINUM_SET_COMMIT';
+export const PARTY_ITEM_CURRENCY_SILVER_SET = 'campaign.PARTY_ITEM_CURRENCY_SILVER_SET';
+export const PARTY_ITEM_CURRENCY_SILVER_SET_COMMIT = 'campaign.PARTY_ITEM_CURRENCY_SILVER_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/campaignSetting.js

@@ -0,0 +1,2 @@
+export const CAMPAIGN_SETTINGS_SET = 'serviceData.CAMPAIGN_SETTINGS_SET';
+export const CAMPAIGN_SETTINGS_SET_COMMIT = 'serviceData.CAMPAIGN_SETTINGS_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/classAlwaysKnownSpells.js

@@ -0,0 +1,2 @@
+export const CLASS_ALWAYS_KNOWN_SPELLS_SET = 'serviceData.CLASS_ALWAYS_KNOWN_SPELLS_SET';
+export const CLASS_ALWAYS_KNOWN_SPELLS_SET_COMMIT = 'serviceData.CLASS_ALWAYS_KNOWN_SPELLS_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/classAlwaysPreparedSpells.js

@@ -0,0 +1,2 @@
+export const CLASS_ALWAYS_PREPARED_SPELLS_SET = 'serviceData.CLASS_ALWAYS_PREPARED_SPELLS_SET';
+export const CLASS_ALWAYS_PREPARED_SPELLS_SET_COMMIT = 'serviceData.CLASS_ALWAYS_PREPARED_SPELLS_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/definitionPool.js

@@ -0,0 +1,2 @@
+export const DEFINITION_POOL_ADD = 'serviceData.DEFINITION_POOL_ADD';
+export const DEFINITION_POOL_ADD_COMMIT = 'serviceData.DEFINITION_POOL_ADD_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/infusionMapping.js

@@ -0,0 +1,7 @@
+export const INFUSION_MAPPING_CREATE = 'serviceData.INFUSION_MAPPING_CREATE';
+export const INFUSION_MAPPING_DESTROY = 'serviceData.INFUSION_MAPPING_DESTROY';
+export const INFUSION_MAPPINGS_DESTROY = 'serviceData.INFUSION_MAPPINGS_DESTROY';
+export const INFUSION_MAPPING_ADD = 'serviceData.INFUSION_MAPPING_ADD';
+export const INFUSION_MAPPING_ADD_COMMIT = 'serviceData.INFUSION_MAPPING_ADD_COMMIT';
+export const INFUSION_MAPPING_REMOVE = 'serviceData.INFUSION_MAPPING_REMOVE';
+export const INFUSION_MAPPING_REMOVE_COMMIT = 'serviceData.INFUSION_MAPPING_REMOVE_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/knownInfusionMapping.js

@@ -0,0 +1,8 @@
+export const KNOWN_INFUSION_MAPPING_CREATE = 'serviceData.KNOWN_INFUSION_MAPPING_CREATE';
+export const KNOWN_INFUSION_MAPPING_DESTROY = 'serviceData.KNOWN_INFUSION_MAPPING_DESTROY';
+export const KNOWN_INFUSION_MAPPING_ADD = 'serviceData.KNOWN_INFUSION_MAPPING_ADD';
+export const KNOWN_INFUSION_MAPPING_ADD_COMMIT = 'serviceData.KNOWN_INFUSION_MAPPING_ADD_COMMIT';
+export const KNOWN_INFUSION_MAPPING_SET = 'serviceData.KNOWN_INFUSION_MAPPING_SET';
+export const KNOWN_INFUSION_MAPPING_SET_COMMIT = 'serviceData.KNOWN_INFUSION_MAPPING_SET_COMMIT';
+export const KNOWN_INFUSION_MAPPING_REMOVE = 'serviceData.KNOWN_INFUSION_MAPPING_REMOVE';
+export const KNOWN_INFUSION_MAPPING_REMOVE_COMMIT = 'serviceData.KNOWN_INFUSION_MAPPING_REMOVE_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/ruleDataPool.js

@@ -0,0 +1,2 @@
+export const RULE_DATA_POOL_KEY_SET = 'serviceData.RULE_DATA_POOL_KEY_SET';
+export const RULE_DATA_POOL_KEY_SET_COMMIT = 'serviceData.RULE_DATA_POOL_KEY_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/vehicleComponentMapping.js

@@ -0,0 +1,6 @@
+export const VEHICLE_COMPONENT_MAPPING_ADD = 'serviceData.VEHICLE_COMPONENT_MAPPING_ADD';
+export const VEHICLE_COMPONENT_MAPPING_ADD_COMMIT = 'serviceData.VEHICLE_COMPONENT_MAPPING_ADD_COMMIT';
+export const VEHICLE_COMPONENT_MAPPING_REMOVE = 'serviceData.VEHICLE_COMPONENT_MAPPING_REMOVE';
+export const VEHICLE_COMPONENT_MAPPING_REMOVE_COMMIT = 'serviceData.VEHICLE_COMPONENT_MAPPING_REMOVE_COMMIT';
+export const VEHICLE_COMPONENT_MAPPING_HIT_POINTS_SET = 'serviceData.VEHICLE_COMPONENT_MAPPING_HIT_POINTS_SET';
+export const VEHICLE_COMPONENT_MAPPING_HIT_POINTS_SET_COMMIT = 'serviceData.VEHICLE_COMPONENT_MAPPING_HIT_POINTS_SET_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actionTypes/vehicleMapping.js

@@ -0,0 +1,15 @@
+export const VEHICLE_MAPPING_CREATE = 'serviceData.VEHICLE_MAPPING_CREATE';
+export const VEHICLE_MAPPING_ADD = 'serviceData.VEHICLE_MAPPING_ADD';
+export const VEHICLE_MAPPING_ADD_COMMIT = 'serviceData.VEHICLE_MAPPING_ADD_COMMIT';
+export const VEHICLE_MAPPING_REMOVE = 'serviceData.VEHICLE_MAPPING_REMOVE';
+export const VEHICLE_MAPPING_REMOVE_COMMIT = 'serviceData.VEHICLE_MAPPING_REMOVE_COMMIT';
+export const VEHICLE_MAPPING_DATA_SET = 'serviceData.VEHICLE_MAPPING_DATA_SET';
+export const VEHICLE_MAPPING_DATA_SET_COMMIT = 'serviceData.VEHICLE_MAPPING_DATA_SET_COMMIT';
+export const VEHICLE_MAPPING_REMAINING_FUEL_SET = 'serviceData.VEHICLE_MAPPING_REMAINING_FUEL_SET';
+export const VEHICLE_MAPPING_REMAINING_FUEL_SET_COMMIT = 'serviceData.VEHICLE_MAPPING_REMAINING_FUEL_SET_COMMIT';
+export const VEHICLE_MAPPING_CONDITION_SET = 'serviceData.VEHICLE_MAPPING_CONDITION_SET';
+export const VEHICLE_MAPPING_CONDITION_SET_COMMIT = 'serviceData.VEHICLE_MAPPING_CONDITION_SET_COMMIT';
+export const VEHICLE_MAPPING_CONDITION_ADD = 'serviceData.VEHICLE_MAPPING_CONDITION_ADD';
+export const VEHICLE_MAPPING_CONDITION_ADD_COMMIT = 'serviceData.VEHICLE_MAPPING_CONDITION_ADD_COMMIT';
+export const VEHICLE_MAPPING_CONDITION_REMOVE = 'serviceData.VEHICLE_MAPPING_CONDITION_REMOVE';
+export const VEHICLE_MAPPING_CONDITION_REMOVE_COMMIT = 'serviceData.VEHICLE_MAPPING_CONDITION_REMOVE_COMMIT';

ddb_main/packages/rules-engine/es/actions/serviceData/actions/campaign.js

@@ -0,0 +1,437 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param item
+ */
+export function partyItemAdd(item) {
+    return {
+        type: actionTypes.PARTY_ITEM_ADD,
+        payload: {
+            item,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_ADD_COMMIT,
+            },
+        },
+    };
+}
+export function partyItemEquippedSet(id, value, equippedEntityId, equippedEntityTypeId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_EQUIPPED_SET,
+        payload: {
+            id,
+            value,
+            equippedEntityId,
+            equippedEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_EQUIPPED_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+export function partyItemAttuneSet(id, value, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_ATTUNE_SET,
+        payload: {
+            id,
+            value,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_ATTUNE_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+export function partyItemQuantitySet(id, quantity, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_QUANTITY_SET,
+        payload: {
+            id,
+            quantity,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_QUANTITY_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+export function partyItemChargesSet(id, uses, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_CHARGES_SET,
+        payload: {
+            id,
+            uses,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_CHARGES_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function partyItemRemove(id, removeContainerContents) {
+    return {
+        type: actionTypes.PARTY_ITEM_REMOVE,
+        payload: {
+            id,
+            removeContainerContents,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param containerEntityId
+ * @param containerEntityTypeId
+ * @param accept
+ * @param reject
+ */
+export function partyItemMoveSet(id, containerEntityId, containerEntityTypeId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_MOVE_SET,
+        payload: {
+            id,
+            containerEntityId,
+            containerEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_MOVE_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ */
+export function partyInventoryRequest() {
+    return {
+        type: actionTypes.PARTY_INVENTORY_REQUEST,
+        payload: null,
+        meta: {},
+    };
+}
+/**
+ * @param campaignInfo
+ */
+export function partyCampaignInfoSet(campaignInfo) {
+    return {
+        type: actionTypes.PARTY_CAMPAIGN_INFO_SET,
+        payload: campaignInfo,
+        meta: {},
+    };
+}
+/**
+ *
+ * @param currencies
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyCurrenciesSet(currencies, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_CURRENCIES_SET,
+        payload: Object.assign(Object.assign({}, currencies), { destinationEntityTypeId,
+            destinationEntityId }),
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_CURRENCIES_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param transactionPayload
+ * @param accept
+ * @param reject
+ */
+export function partyCurrencyTransactionSet(transactionPayload, accept, reject) {
+    return {
+        type: actionTypes.PARTY_CURRENCY_TRANSACTION_SET,
+        payload: Object.assign({}, transactionPayload),
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyCurrencyCopperSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_CURRENCY_COPPER_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_CURRENCY_COPPER_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyCurrencyElectrumSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_CURRENCY_ELECTRUM_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_CURRENCY_ELECTRUM_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyCurrencyGoldSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_CURRENCY_GOLD_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_CURRENCY_GOLD_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyCurrencyPlatinumSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_CURRENCY_PLATINUM_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_CURRENCY_PLATINUM_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyCurrencySilverSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_CURRENCY_SILVER_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_CURRENCY_SILVER_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param currencies
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ * @param accept
+ * @param reject
+ */
+export function partyItemCurrencySet(currency, id, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_CURRENCY_SET,
+        payload: {
+            currency,
+            id,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_CURRENCY_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyItemCurrencyCopperSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_CURRENCY_COPPER_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_CURRENCY_COPPER_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyItemCurrencySilverSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_CURRENCY_SILVER_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_CURRENCY_SILVER_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyItemCurrencyElectrumSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_CURRENCY_ELECTRUM_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_CURRENCY_ELECTRUM_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyItemCurrencyGoldSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_CURRENCY_GOLD_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_CURRENCY_GOLD_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param amount
+ * @param destinationEntityTypeId
+ * @param destinationEntityId
+ */
+export function partyItemCurrencyPlatinumSet(amount, destinationEntityTypeId, destinationEntityId, accept, reject) {
+    return {
+        type: actionTypes.PARTY_ITEM_CURRENCY_PLATINUM_SET,
+        payload: {
+            amount,
+            destinationEntityId,
+            destinationEntityTypeId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.PARTY_ITEM_CURRENCY_PLATINUM_SET_COMMIT,
+            },
+            accept,
+            reject,
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/campaignSetting.js

@@ -0,0 +1,12 @@
+import * as actionTypes from '../actionTypes';
+export function campaignSettingsSet(campaignSettings) {
+    return {
+        type: actionTypes.CAMPAIGN_SETTINGS_SET,
+        payload: campaignSettings,
+        meta: {
+            commit: {
+                type: actionTypes.CAMPAIGN_SETTINGS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/classAlwaysKnownSpells.js

@@ -0,0 +1,20 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param spells
+ * @param classId
+ */
+export function classAlwaysKnownSpellsSet(spells, classId) {
+    return {
+        type: actionTypes.CLASS_ALWAYS_KNOWN_SPELLS_SET,
+        payload: {
+            spells,
+            classId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CLASS_ALWAYS_KNOWN_SPELLS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/classAlwaysPreparedSpells.js

@@ -0,0 +1,20 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param spells
+ * @param classId
+ */
+export function classAlwaysPreparedSpellsSet(spells, classId) {
+    return {
+        type: actionTypes.CLASS_ALWAYS_PREPARED_SPELLS_SET,
+        payload: {
+            spells,
+            classId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.CLASS_ALWAYS_PREPARED_SPELLS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/definitionPool.js

@@ -0,0 +1,22 @@
+import { DefinitionPoolGenerators } from '../../../engine/DefinitionPool';
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param definitions
+ * @param definitionAccessTypeLookup
+ */
+export function definitionPoolAdd(definitions, definitionAccessTypeLookup) {
+    return {
+        type: actionTypes.DEFINITION_POOL_ADD,
+        payload: {
+            type: DefinitionPoolGenerators.generatePoolDefinitionType(definitions[0]),
+            definitions: DefinitionPoolGenerators.generatePoolDefinitionItems(definitions),
+            definitionAccessTypeLookup,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.DEFINITION_POOL_ADD_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/infusionMapping.js

@@ -0,0 +1,74 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param payload
+ */
+export function infusionMappingCreate(payload) {
+    return {
+        type: actionTypes.INFUSION_MAPPING_CREATE,
+        payload,
+        meta: {},
+    };
+}
+/**
+ *
+ * @param infusionMapping
+ */
+export function infusionMappingAdd(infusionMapping) {
+    return {
+        type: actionTypes.INFUSION_MAPPING_ADD,
+        payload: infusionMapping,
+        meta: {
+            commit: {
+                type: actionTypes.INFUSION_MAPPING_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param infusionId
+ * @param inventoryMappingId
+ */
+export function infusionMappingDestroy(infusionId, inventoryMappingId) {
+    return {
+        type: actionTypes.INFUSION_MAPPING_DESTROY,
+        payload: {
+            infusionId,
+            inventoryMappingId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param itemMappingIds
+ */
+export function infusionMappingsDestroy(itemMappingIds) {
+    return {
+        type: actionTypes.INFUSION_MAPPINGS_DESTROY,
+        payload: {
+            ids: itemMappingIds,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param infusionId
+ * @param inventoryMappingId
+ */
+export function infusionMappingRemove(infusionId, inventoryMappingId) {
+    return {
+        type: actionTypes.INFUSION_MAPPING_REMOVE,
+        payload: {
+            infusionId,
+            inventoryMappingId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.INFUSION_MAPPING_REMOVE_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/knownInfusionMapping.js

@@ -0,0 +1,88 @@
+import { DefinitionGenerators, DefinitionTypeEnum } from '../../../engine/Definition';
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param choiceKey
+ * @param infusionId
+ */
+export function knownInfusionMappingCreate(choiceKey, infusionId) {
+    return {
+        type: actionTypes.KNOWN_INFUSION_MAPPING_CREATE,
+        payload: {
+            choiceKey,
+            infusionId,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param infusionKnownMapping
+ */
+export function knownInfusionMappingAdd(infusionKnownMapping) {
+    return {
+        type: actionTypes.KNOWN_INFUSION_MAPPING_ADD,
+        payload: infusionKnownMapping,
+        meta: {
+            commit: {
+                type: actionTypes.KNOWN_INFUSION_MAPPING_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param choiceKey
+ */
+export function knownInfusionMappingDestroy(choiceKey) {
+    return {
+        type: actionTypes.KNOWN_INFUSION_MAPPING_DESTROY,
+        payload: {
+            choiceKey,
+        },
+        meta: {},
+    };
+}
+/**
+ *
+ * @param choiceKey
+ * @param infusionId
+ * @param itemId
+ * @param itemTypeId
+ * @param itemName
+ */
+export function knownInfusionMappingSet(choiceKey, infusionId, itemId, itemTypeId, itemName) {
+    return {
+        type: actionTypes.KNOWN_INFUSION_MAPPING_SET,
+        payload: {
+            choiceKey,
+            infusionId,
+            definitionKey: DefinitionGenerators.generateDefinitionKey(DefinitionTypeEnum.INFUSION, infusionId),
+            itemId,
+            itemTypeId,
+            itemName,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.KNOWN_INFUSION_MAPPING_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param choiceKey
+ */
+export function knownInfusionMappingRemove(choiceKey) {
+    return {
+        type: actionTypes.KNOWN_INFUSION_MAPPING_REMOVE,
+        payload: {
+            choiceKey,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.KNOWN_INFUSION_MAPPING_REMOVE_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/ruleDataPool.js

@@ -0,0 +1,15 @@
+import * as actionTypes from '../actionTypes';
+export function ruleDataPoolKeySet(key, data) {
+    return {
+        type: actionTypes.RULE_DATA_POOL_KEY_SET,
+        payload: {
+            key,
+            data,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.RULE_DATA_POOL_KEY_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/vehicleComponentMapping.js

@@ -0,0 +1,54 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param component
+ */
+export function vehicleComponentMappingAdd(component) {
+    return {
+        type: actionTypes.VEHICLE_COMPONENT_MAPPING_ADD,
+        payload: {
+            component,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_COMPONENT_MAPPING_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function vehicleComponentMappingRemove(id) {
+    return {
+        type: actionTypes.VEHICLE_COMPONENT_MAPPING_REMOVE,
+        payload: {
+            id,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_COMPONENT_MAPPING_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param removedHitPoints
+ */
+export function vehicleComponentMappingHitPointsSet(id, removedHitPoints) {
+    return {
+        type: actionTypes.VEHICLE_COMPONENT_MAPPING_HIT_POINTS_SET,
+        payload: {
+            id,
+            removedHitPoints,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_COMPONENT_MAPPING_HIT_POINTS_SET_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/actions/vehicleMapping.js

@@ -0,0 +1,158 @@
+import * as actionTypes from '../actionTypes';
+/**
+ *
+ * @param vehicleId
+ * @param name
+ * @param accept
+ * @param reject
+ */
+export function vehicleMappingCreate(vehicleId, name, accept, reject) {
+    return {
+        type: actionTypes.VEHICLE_MAPPING_CREATE,
+        payload: {
+            vehicleId,
+            name,
+        },
+        meta: {
+            accept,
+            reject,
+        },
+    };
+}
+/**
+ *
+ * @param vehicle
+ */
+export function vehicleMappingAdd(vehicle) {
+    return {
+        type: actionTypes.VEHICLE_MAPPING_ADD,
+        payload: {
+            vehicle,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_MAPPING_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ */
+export function vehicleMappingRemove(id) {
+    return {
+        type: actionTypes.VEHICLE_MAPPING_REMOVE,
+        payload: {
+            id,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_MAPPING_REMOVE_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param id
+ * @param properties
+ */
+export function vehicleMappingDataSet(id, properties) {
+    return {
+        type: actionTypes.VEHICLE_MAPPING_DATA_SET,
+        payload: {
+            id,
+            properties,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_MAPPING_DATA_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param vehicleMappingId
+ * @param remainingFuel
+ */
+export function vehicleMappingRemainingFuelSet(vehicleMappingId, remainingFuel) {
+    return {
+        type: actionTypes.VEHICLE_MAPPING_REMAINING_FUEL_SET,
+        payload: {
+            vehicleMappingId,
+            remainingFuel,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_MAPPING_REMAINING_FUEL_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param vehicleMappingId
+ * @param conditionId
+ * @param level
+ */
+export function vehicleMappingConditionSet(vehicleMappingId, conditionId, level) {
+    return {
+        type: actionTypes.VEHICLE_MAPPING_CONDITION_SET,
+        payload: {
+            vehicleMappingId,
+            mappingContract: {
+                conditionId,
+                level,
+            },
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_MAPPING_CONDITION_SET_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param vehicleMappingId
+ * @param conditionId
+ * @param level
+ */
+export function vehicleMappingConditionAdd(vehicleMappingId, conditionId, level) {
+    return {
+        type: actionTypes.VEHICLE_MAPPING_CONDITION_ADD,
+        payload: {
+            vehicleMappingId,
+            mappingContract: {
+                conditionId,
+                level,
+            },
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_MAPPING_CONDITION_ADD_COMMIT,
+            },
+        },
+    };
+}
+/**
+ *
+ * @param vehicleMappingId
+ * @param conditionId
+ */
+export function vehicleMappingConditionRemove(vehicleMappingId, conditionId) {
+    return {
+        type: actionTypes.VEHICLE_MAPPING_CONDITION_REMOVE,
+        payload: {
+            vehicleMappingId,
+            conditionId,
+        },
+        meta: {
+            commit: {
+                type: actionTypes.VEHICLE_MAPPING_CONDITION_REMOVE_COMMIT,
+            },
+        },
+    };
+}

ddb_main/packages/rules-engine/es/actions/serviceData/index.js

@@ -0,0 +1,6 @@
+import * as actionTypes from './actionTypes';
+import * as actions from './actions';
+import * as typings from './typings';
+export const serviceDataActionTypes = actionTypes;
+export const serviceDataActions = actions;
+export const serviceDataTypings = typings;

ddb_main/packages/rules-engine/es/actions/syncTransaction/actionTypes.js

@@ -0,0 +1,2 @@
+export const ACTIVATE = 'syncTransaction.ACTIVATE';
+export const DEACTIVATE = 'syncTransaction.DEACTIVATE';

ddb_main/packages/rules-engine/es/actions/syncTransaction/actions.js

@@ -0,0 +1,21 @@
+import * as actionTypes from './actionTypes';
+/**
+ *
+ * @param initiator
+ */
+export function activate(initiator) {
+    return {
+        type: actionTypes.ACTIVATE,
+        payload: {
+            initiator,
+        },
+    };
+}
+/**
+ *
+ */
+export function deactivate() {
+    return {
+        type: actionTypes.DEACTIVATE,
+    };
+}

ddb_main/packages/rules-engine/es/actions/syncTransaction/index.js

@@ -0,0 +1,6 @@
+import * as actionTypes from './actionTypes';
+import * as actions from './actions';
+import * as typings from './typings';
+export const syncTransactionActionTypes = actionTypes;
+export const syncTransactionActions = actions;
+export const syncTransactionTypings = typings;

ddb_main/packages/rules-engine/es/api/constants.js

@@ -0,0 +1,14 @@
+import { DefinitionTypeEnum } from '../engine/Definition';
+export var ApiTypeEnum;
+(function (ApiTypeEnum) {
+    ApiTypeEnum["GAME_DATA_SERVICE"] = "GAME_DATA_SERVICE";
+    ApiTypeEnum["CHARACTER_SERVICE"] = "CHARACTER_SERVICE";
+    ApiTypeEnum["WEBSITE"] = "WEBSITE";
+    ApiTypeEnum["HACK__CHARACTER_SERVICE_GAME_DATA"] = "HACK__CHARACTER_SERVICE_GAME_DATA";
+})(ApiTypeEnum || (ApiTypeEnum = {}));
+export const DEFINITION_SERVICE_VERSIONS = {
+    [DefinitionTypeEnum.INFUSION]: 1,
+    [DefinitionTypeEnum.VEHICLE]: 4,
+};
+export const CHARACTER_SERVICE_VERSION_KEY = 'v5';
+export const CHARACTER_SERVICE_VERSION_KEY_OVERRIDE = 'v5.1';

ddb_main/packages/rules-engine/es/api/generators.js

@@ -0,0 +1,29 @@
+import { CampaignAccessors } from '../engine/Campaign';
+import { ContentSharingSettingEnum } from '../engine/Core';
+import { CHARACTER_SERVICE_VERSION_KEY } from './constants';
+/**
+ *
+ * @param apiPath
+ */
+export function generateCharacterServiceApiPath(apiPath, apiVersionOverride) {
+    return ['character', apiVersionOverride !== null && apiVersionOverride !== void 0 ? apiVersionOverride : CHARACTER_SERVICE_VERSION_KEY, apiPath].join('/');
+}
+/**
+ *
+ * @param campaign
+ */
+export function generateRequiredGameDataServiceParams(campaign) {
+    return {
+        campaignId: campaign === null ? null : CampaignAccessors.getId(campaign),
+        sharingSetting: ContentSharingSettingEnum.SCOPE_TO_INDIVIDUAL_CAMPAIGN,
+    };
+}
+/**
+ *
+ * @param characterId
+ */
+export function generateRequiredCharacterServiceParams(characterId) {
+    return {
+        characterId,
+    };
+}

ddb_main/packages/rules-engine/es/api/hacks.js

@@ -0,0 +1,12 @@
+import * as ApiAdapterUtils from '../apiAdapter/utils';
+import { ApiTypeEnum } from './constants';
+import { getGameDataDefinitionTypeBasePath } from './utils';
+/**
+ *
+ * @param definitionType
+ * @param config
+ */
+export function hack__characterServiceMakeGetIdsDefinitionTypeRequest(definitionType, config) {
+    let apiPath = ['game-data', getGameDataDefinitionTypeBasePath(definitionType), 'collection'].join('/');
+    return ApiAdapterUtils.makePost(ApiTypeEnum.HACK__CHARACTER_SERVICE_GAME_DATA, apiPath, config);
+}

ddb_main/packages/rules-engine/es/api/requestHelpers/character/spell.js

@@ -0,0 +1,46 @@
+/**
+ *
+ * @param level
+ */
+export function getSpellLevelPactMagicRequestsDataKey(level) {
+    switch (level) {
+        case 1:
+            return 'level1';
+        case 2:
+            return 'level2';
+        case 3:
+            return 'level3';
+        case 4:
+            return 'level4';
+        case 5:
+            return 'level5';
+    }
+    return null;
+}
+/**
+ *
+ * @param level
+ */
+export function getSpellLevelSpellSlotRequestsDataKey(level) {
+    switch (level) {
+        case 1:
+            return 'level1';
+        case 2:
+            return 'level2';
+        case 3:
+            return 'level3';
+        case 4:
+            return 'level4';
+        case 5:
+            return 'level5';
+        case 6:
+            return 'level6';
+        case 7:
+            return 'level7';
+        case 8:
+            return 'level8';
+        case 9:
+            return 'level9';
+    }
+    return null;
+}

ddb_main/packages/rules-engine/es/api/requests/character/action/requests.js

@@ -0,0 +1,6 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ *
+ */
+export const putCharacterActionLimitedUse = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'action/limited-use');

ddb_main/packages/rules-engine/es/api/requests/character/background/requests.js

@@ -0,0 +1,18 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ *
+ */
+export const putCharacterBackground = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'background');
+/**
+ *
+ */
+export const putCharacterBackgroundChoice = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'background/choice');
+/**
+ *
+ */
+export const putCharacterCustomBackground = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/background');
+/**
+ *
+ */
+export const putCharacterConfigurationHasCustomBackground = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'configuration/has-custom-background');

ddb_main/packages/rules-engine/es/api/requests/character/builder/requests.js

@@ -0,0 +1,20 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ *
+ */
+export const postCharacterBuilderStandardBuild = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'builder/standard-build', {
+    removeDefaultParams: true,
+});
+/**
+ *
+ */
+export const postCharacterBuilderRandomBuild = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'builder/random-build', {
+    removeDefaultParams: true,
+});
+/**
+ *
+ */
+export const postCharacterBuilderQuickBuild = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'builder/quick-build', {
+    removeDefaultParams: true,
+});

ddb_main/packages/rules-engine/es/api/requests/character/campaign/requests.js

@@ -0,0 +1,5 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+export const getPartyInventory = ApiAdapterUtils.makeInterpolatedGet(ApiTypeEnum.CHARACTER_SERVICE, 'party/inventory/{campaignId}', { removeDefaultParams: true });
+// This response should have the sharing state on it
+// shareStatus = `ON` (fully working, paid) `OFF` (should not be on) `DELETE_ONLY` (turned off, but still has things. Can claim or move out of campaign or delete, no adding more to the container)

ddb_main/packages/rules-engine/es/api/requests/character/campaignSetting/requests.js

@@ -0,0 +1,14 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ * Get data for single campaign setting
+ */
+export const getCampaignSetting = ApiAdapterUtils.makeInterpolatedGet(ApiTypeEnum.GAME_DATA_SERVICE, 'campaign-settings/v1/campaign-settings/{id}');
+/**
+ * Get data for all campaign settings
+ */
+export const getAllCampaignSettings = ApiAdapterUtils.makeGet(ApiTypeEnum.GAME_DATA_SERVICE, 'campaign-settings/v1/campaign-settings');
+/**
+ * Update campaign setting on character
+ */
+export const putCharacterCampaignSetting = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'campaign-setting');

ddb_main/packages/rules-engine/es/api/requests/character/character/requests.js

@@ -0,0 +1,47 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ *
+ */
+export const putCharacterAbilityScore = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'character/ability-score');
+/**
+ *
+ */
+export const putCharacterAbilityScoreType = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'character/ability-score/type');
+/**
+ *
+ */
+export const putCharacterHelpText = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'character/help-text');
+/**
+ *
+ */
+export const getCharacterRestShort = ApiAdapterUtils.makeGet(ApiTypeEnum.CHARACTER_SERVICE, 'character/rest/short');
+/**
+ *
+ */
+export const postCharacterRestShort = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'character/rest/short');
+/**
+ *
+ */
+export const getCharacterRestLong = ApiAdapterUtils.makeGet(ApiTypeEnum.CHARACTER_SERVICE, 'character/rest/long');
+/**
+ *
+ */
+export const postCharacterRestLong = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'character/rest/long');
+/**
+ *
+ */
+export const putCharacterProgression = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'character/progression');
+/**
+ *
+ */
+export const putCharacterPreferences = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'character/preferences');
+/**
+ *
+ */
+export const putCharacterSourceCategories = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'character/source-categories');
+export const putCharacterSources = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, `campaign-setting`);
+/**
+ *
+ */
+export const putCharacterInspiration = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'character/inspiration');

ddb_main/packages/rules-engine/es/api/requests/character/class/requests.js

@@ -0,0 +1,18 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ *
+ */
+export const postCharacterClass = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'class');
+/**
+ *
+ */
+export const deleteCharacterClass = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'class');
+/**
+ *
+ */
+export const putCharacterClassLevel = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'class/level');
+/**
+ *
+ */
+export const putCharacterClassFeatureChoice = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'class/feature/choice');

ddb_main/packages/rules-engine/es/api/requests/character/condition/requests.js

@@ -0,0 +1,10 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ *
+ */
+export const putCharacterCondition = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'condition');
+/**
+ *
+ */
+export const deleteCharacterCondition = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'condition');

ddb_main/packages/rules-engine/es/api/requests/character/creature/requests.js

@@ -0,0 +1,22 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ *
+ */
+export const postCharacterCreature = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'creature');
+/**
+ *
+ */
+export const deleteCharacterCreature = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'creature');
+/**
+ *
+ */
+export const putCharacterCreature = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'creature');
+/**
+ *
+ */
+export const putCharacterCreatureStatus = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'creature/status');
+/**
+ *
+ */
+export const putCharacterCreatureHp = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'creature/hp');

ddb_main/packages/rules-engine/es/api/requests/character/custom/requests.js

@@ -0,0 +1,98 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum, CHARACTER_SERVICE_VERSION_KEY_OVERRIDE } from '../../../constants';
+/**
+ *
+ */
+export const putCharacterCustomValue = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/value');
+/**
+ *
+ */
+export const deleteCharacterCustomValue = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/value');
+/**
+ *
+ */
+export const deleteCharacterCustomEntityValues = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/entity/values');
+/**
+ *
+ */
+export const postCharacterCustomProficiency = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'custom/proficiency');
+/**
+ *
+ */
+export const putCharacterCustomProficiency = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/proficiency');
+/**
+ *
+ */
+export const deleteCharacterCustomProficiency = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/proficiency');
+/**
+ *
+ */
+export const postCharacterCustomMovement = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'custom/movement');
+/**
+ *
+ */
+export const putCharacterCustomMovement = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/movement');
+/**
+ *
+ */
+export const deleteCharacterCustomMovement = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/movement');
+/**
+ *
+ */
+export const postCharacterCustomAction = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'custom/action');
+/**
+ *
+ */
+export const deleteCharacterCustomAction = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/action');
+/**
+ *
+ */
+export const putCharacterCustomAction = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/action');
+/**
+ * TODO v5.1: Remove this and usages when mobile moves up
+ */
+export const postCharacterCustomItemV5 = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'custom/item');
+/**
+ * TODO v5.1: Remove this and usages when mobile moves up
+ */
+export const deleteCharacterCustomItemV5 = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/item');
+/**
+ * TODO v5.1: Remove this and usages when mobile moves up
+ */
+export const putCharacterCustomItemV5 = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/item');
+/**
+ *
+ */
+export const postCharacterCustomItem = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'custom/item', undefined, CHARACTER_SERVICE_VERSION_KEY_OVERRIDE);
+/**
+ *
+ */
+export const deleteCharacterCustomItem = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/item', undefined, CHARACTER_SERVICE_VERSION_KEY_OVERRIDE);
+/**
+ *
+ */
+export const putCharacterCustomItem = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/item', undefined, CHARACTER_SERVICE_VERSION_KEY_OVERRIDE);
+/**
+ *
+ */
+export const postCharacterCustomSense = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'custom/sense');
+/**
+ *
+ */
+export const putCharacterCustomSense = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/sense');
+/**
+ *
+ */
+export const deleteCharacterCustomSense = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/sense');
+/**
+ *
+ */
+export const postCharacterCustomDefenseAdjustment = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'custom/defense-adjustment');
+/**
+ *
+ */
+export const putCharacterCustomDefenseAdjustment = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'custom/defense-adjustment');
+/**
+ *
+ */
+export const deleteCharacterCustomDefenseAdjustment = ApiAdapterUtils.makeDelete(ApiTypeEnum.CHARACTER_SERVICE, 'custom/defense-adjustment');

ddb_main/packages/rules-engine/es/api/requests/character/decoration/requests.js

@@ -0,0 +1,26 @@
+import * as ApiAdapterUtils from '../../../../apiAdapter/utils';
+import { ApiTypeEnum } from '../../../constants';
+/**
+ *
+ */
+export const putCharacterDecorationBackdrop = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'decoration/backdrop');
+/**
+ *
+ */
+export const putCharacterDecorationFrame = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'decoration/frame');
+/**
+ *
+ */
+export const putCharacterDecorationPortrait = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'decoration/portrait');
+/**
+ * user uploaded portrait file
+ */
+export const postCharacterDecorationPortraitCustom = ApiAdapterUtils.makePost(ApiTypeEnum.CHARACTER_SERVICE, 'decoration/portrait/custom');
+/**
+ *
+ */
+export const putCharacterDecorationThemeColor = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'decoration/theme-color');
+/**
+ *
+ */
+export const putCharacterDecorationSocialImage = ApiAdapterUtils.makePut(ApiTypeEnum.CHARACTER_SERVICE, 'decoration/social-image');