const findBalance = require('daniel-san');
const createReport = require('daniel-san/reporting');
const { STANDARD_EVENT, MONTHLY, WEEKLY, DAILY, FRIDAY, SATURDAY, SUNDAY } = require('daniel-san/constants');

const danielSan = {
    config: {
        balanceBeginning: 1618.03, // always required / the final balanceBeginning and balanceEnding results will be added to the root of this danielSan bonsai-tree
        effectiveDateStart: '2019-03-20', // always required - inclusive (effectiveDateStart is included in the budget projection)
        effectiveDateEnd: '2019-12-13', // always required - inclusive (effectiveDateEnd is included in the budget projection)
        timeStart: null, // optional: '09:00am'
        timeEnd: null // optional: '05:00pm'
    },
    rules: [
        {
            // rule 1
            name: 'monthly bitcoin investment',
            amount: -79.83, // negative amount subtracts, positive amount adds
            type: STANDARD_EVENT, // see "Event Types" - import from constants.js / see list of importable constants at the bottom of this readme
            frequency: MONTHLY,
            processDate: '30', // for MONTHLY events, this string represents the day within that month
            effectiveDateStart: '2019-01-01', // date to start evaluating and processing this account, if there is no start date, daniel-san will determine the first process date
            effectiveDateEnd: null, // null effectiveDateEnd represents an ongoing account
            modulus: 1, // not required - for BIWEEKLY / BIMONTHLY types of events - see "Modulus/Cycle" to review this advanced feature
            cycle: 1 // not required - for BIWEEKLY / BIMONTHLY types of events - see "Modulus/Cycle" to review this advanced feature
        },
        {
            // rule 2
            name: 'shenanigans',
            amount: -97.0,
            type: STANDARD_EVENT, // see "Event Types" - import from constants.js
            frequency: WEEKLY,
            processDate: FRIDAY, // 0-6 (Number) with 0 representing Sunday - weekday constants are available to be imported
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null, // null effectiveDateEnd represents an ongoing account
            modulus: 2, // See "Modulus/Cycle" to review this advanced feature
            cycle: 1 // the modulus/cycle attributes here equate to every other Weekday (in this particular case due to the WEEKLY frequency)
        },
        {
            // rule 3
            type: STANDARD_EVENT,
            frequency: DAILY,
            name: 'cafeteria breakfast',
            amount: -5.0,
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
            exclusions: {
                // exclusion matches will still modulate the cycle when using the modulus/cycle feature
                weekdays: [SATURDAY, SUNDAY], // excluding these weekdays (you could have also just imported the WEEKENDS constant and spreaded it within the array here)
                dates: ['2019-07-04', '2019-09-17', '2019-10-31'] // exluding these specific dates (always in this exact string format: YYYY-MM-DD)
            }
        },
        {
            // rule 4
            name: 'fitness routine',
            type: STANDARD_EVENT_ROUTINE, // no amount field needed
            frequency: WEEKLY,
            processDate: SATURDAY,
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
            note: '20 minutes of jogging, 20 minutes of cycling, free weights'
        },
        {
            // rule 5
            name: 'new years party arrangements',
            type: STANDARD_EVENT_REMINDER, // no amount field needed
            frequency: DAILY, // no processDate needed for DAILY events
            effectiveDateStart: '2020-12-13',
            effectiveDateEnd: '2020-12-21', // remind me daily until the 21st
            note: 'finalize arrangements for the party'
        }
    ],
    events: [] // future balance projections stored here and a balanceEnding field is assigned to each event
};

const craneKick = findBalance(danielSan);

// after executing findBalance with danielSan, craneKick will embody the danielSan object with the newly produced events,
// and it will contain an object called "err" if there are errors during execution
const craneKick = findBalance(danielSan);

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2019-03-20',
        effectiveDateEnd: '2019-12-13'
    },
    rules: [
        { // rule 1
            name: 'monthly bitcoin investment',
            amount: -79.83,
            type: STANDARD_EVENT,
            frequency: MONTHLY, // if a MONTHLY processDate is greater than days in month, it resorts to match against the last day of the month;
                                // so 31 will always execute on the last day of the month
            processDate: '28',
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null
        },
        { // rule 2
            name: 'tri-monthly stipend',
            amount: 2035.56, // positive amount signifies an inflow of cash
            type: STANDARD_EVENT,
            frequency: MONTHLY,
            processDate: '01',
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: '2019-12-13'
            modulus: 3, // this attribute signifies every THIRD match will trigger a processing event
            cycle: 1 // the current cycle of this modulation phase - see "Modulus/Cycle" to review this advanced feature
        },
    ],
    events: [] // future balance projections stored here
};

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2019-03-20',
        effectiveDateEnd: '2019-12-13'
    },
    rules: [
        {
            // rule 1
            name: 'monthly bitcoin investment',
            amount: -79.83,
            type: NTH_WEEKDAYS_OF_MONTH, // see "Event Types" - import from constants.js
            frequency: [
                { rank: 1, weekday: FRIDAY }, // every 1st friday
                { rank: 3, weekday: FRIDAY }, // and 3rd friday
                { rank: -1, weekday: SUNDAY } // a negative rank means the last occurence of the month
            ],
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null
        },
        {
            // rule 2
            name: 'jasons birthday party',
            amount: -66.6,
            type: WEEKDAY_ON_DATE, // see "Event Types" - import from constants.js
            frequency: [
                { processDate: '13', weekday: FRIDAY } // process this frequency element every friday the 13th, add more elements as desired
            ],
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null
        }
    ],
    events: [] // future balance projections stored here
};

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2019-03-20',
        effectiveDateEnd: '2019-12-13'
    },
    rules: [
        {
            // rule 1
            name: 'le cinema',
            amount: -23.57,
            type: STANDARD_EVENT,
            frequency: WEEKLY,
            processDate: 0, // 0-6 (Number) with 0 representing Sunday - weekday constants are available to be imported, such as FRIDAY
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
            specialAdjustments: [
                {
                    // the moving of process dates should generally come last in the array of adjustments
                    // the below type is synonymous with MOVE_THIS_PROCESS_DATE_BEFORE_THESE_DATES
                    type: PRE_PAY, // to postpay after the specified dates, use POST_PAY or the equivalent constant, MOVE_THIS_PROCESS_DATE_AFTER_THESE_DATES
                    dates: ['2019-07-04', '2019-12-25'], // if a processing date falls on one of these dates it will roll back to precede it
                    weekdays: [SATURDAY, SUNDAY] // weekdays are optional for both PRE_PAY and POST_PAY. If falling on a provided weekday, it will roll back to precede it
                }
            ]
        },
        {
            // rule 2, this specific specialAdjustment example focuses on weekdays ONLY
            name: 'fortress mortgage',
            amount: -2357.11,
            type: STANDARD_EVENT,
            frequency: MONTHLY,
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
            specialAdjustments: [
                {
                    // the moving of process dates should generally come last in the array of adjustments
                    type: MOVE_THIS_PROCESS_DATE_AFTER_THESE_WEEKDAYS, // to prepay before the specified days, use MOVE_THIS_PROCESS_DATE_BEFORE_THESE_WEEKDAYS
                    weekdays: [SATURDAY, SUNDAY]
                }
            ]
        },
        {
            // rule 3
            name: 'monthly bitcoin investment',
            amount: -79.83,
            type: NTH_WEEKDAYS_OF_MONTH, // see "Event Types" - import from constants.js
            frequency: [
                { rank: 1, weekday: FRIDAY }, // every 1st friday
                { rank: 3, weekday: FRIDAY }, // and 3rd friday
                { rank: -1, weekday: SUNDAY } // a negative rank means the last occurence of the month
            ],
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
            specialAdjustments: [
                {
                    type: ADJUST_AMOUNT,
                    dates: ['2019-09-17', '2019-12-25'],
                    amounts: [223.0, 271.0] // dates and amounts are parallel arrays
                }
            ]
        }
    ],
    events: [] // future balance projections stored here
};

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2020-09-17',
        effectiveDateEnd: '2019-12-13'
    },
    rules: [
        {
            // rule 1
            name: 'monthly bitcoin investment',
            amount: -79.83,
            type: STANDARD_EVENT,
            frequency: MONTHLY,
            processDate: '30',
            effectiveDateStart: '2019-01-01', // since the effectiveDateStart is set BEFORE the config's effectiveDateStart, the cycle will start on 2019-09-17
            effectiveDateEnd: null,
            modulus: 3,
            cycle: 1
        },
        {
            // rule 2
            name: 'shenanigans',
            amount: -97.0,
            type: STANDARD_EVENT, // see "Event Types" - import from constants.js
            frequency: WEEKLY,
            processDate: FRIDAY, // 0-6 (Number) with 0 representing Sunday - weekday constants are available to be imported
            anchorSyncDate: '2019-08-12', // you can actually just use effectiveDateStart here, instead of anchorSyncDate, since version 6.1.0, although anchorSyncDate is still being used in the background
            effectiveDateEnd: null,
            modulus: 2, // the modulus/cycle attributes here equate to every other Weekday (in this particular case due to the WEEKLY frequency)
            cycle: 1
        }
    ],
    events: [] // future balance projections stored here
};

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2019-03-20',
        effectiveDateEnd: '2019-12-13'
    },
    rules: [
        {
            // rule 1
            type: STANDARD_EVENT,
            frequency: MONTHLY,
            name: 'projected revenue',
            amount: +25.0,
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
            ruleModification: ({ danielSan, rule, date, convertedDate }) => {
                // every SUNDAY, we expect that day of revenue to increase by 100
                // so the first SUNDAY it adds 25 to the balanceEnding field, and the next SUNDAY it adds 125, and the next, 225, etc..
                if (convertedDate.day() === 0) {
                    rule.amount += 100; // if you were modifying an expense (instead of revenue) you'd subtract from the amount field instead, for example, when anticipating greater losses
                }
            }
        }
    ],
    events: [] // future balance projections stored here
};

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2019-03-20',
        effectiveDateEnd: '2019-12-13'
    },
    rules: [
        {
            // rule 1
            type: STANDARD_EVENT,
            frequency: DAILY,
            name: 'cafeteria breakfast',
            amount: -5.0,
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
            exclusions: {
                // (exclusion hits will still modulate the cycle for STANDARD_EVENT)
                weekdays: [SATURDAY, SUNDAY], // event triggers will exclude these weekdays
                dates: ['2019-07-04', '2019-09-17', '2019-10-31'] // and exclude these specific dates
            }
        }
    ],
    events: [] // future balance projections stored here
};

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2019-03-20',
        effectiveDateEnd: '2019-12-13',
        currencySymbol: 'USD', // the PRIMARY-OUTPUT currency symbol that everything will be converted to, it represents the outputSymbol parameter in the currencyConversion function
        // (when using the reportController, the currencySymbol parameter should be exact/case-sensitive as respected by javascripts built-in toLocaleString function - via the Intl api)
        currencyConversion: ({ amount, inputSymbol, outputSymbol }) => {
            // a global currency conversion function that will return the converted amount.
            // the amount parameter represents the rule amount (as defined below for each provided rule)
            // the inputSymbol parameter here represents the currencySymbol property field from the rule
            // outputSymbol represents the output currency you will be converting to (the primary-output USD value above, as defined in the config branch)
            // even if you do not add a currencyConversion function, a default function is added to the danielSan object for you
            // (so a currencyConversion function is used in every calculation, regardless, which by default returns the same amount passed in)
            const UsdSymbolEnum = {
                'USD': 1,   // in this case, USD represents the root field of this usd enum so its conversion factor should be 1, since 1 USD is worth 1 USD
                'EUR': 0.88, // 1 USD is worth 0.88 EUR
                'CNY': 6.75 // 1 USD is worth 6.75 CNY
            };

            const EurSymbolEnum = {
                'EUR': 1,
                'USD': 1.14,
                'CNY': 0.15
            };
            // you may have a need for multiple switch-case rules (and associated  enums) that execute based on different primary-output currency symbols
            // eg. when switching your primary-output currency symbol to some other symbol, (as shown above the currencyConversion function)
            // so for each possible primary-output, you need to define different enums for potential output and/or input symbol (notice the EUR case example below)
            switch (outputSymbol) {
            case 'USD': // since our primary-output is USD, this case will convert the rule amount symbol (CNY) to USD
                return amount * (UsdSymbolEnum[inputSymbol] || 1); // defensive programming example in cases when inputSymbol is null/undefined
            case 'EUR': // this case would only execute if you changed your primary-output symbol to EUR
                return amount * (EurSymbolEnum[inputSymbol] || 1);
            default:
                return amount;
            }
            // since this function provides you with all the necessary parameters,
            // you could of course create your currencyConversion function however you want as long as it computes and returns accurate results
            // if you are using an api call to get real time figures for the enums prior to running your projections,
            // you could just define the currencyConversion function dynamically at runtime
        }
    },
    rules: [
        { // rule 1
            type: STANDARD_EVENT,
            frequency: DAILY,
            name: 'cafeteria breakfast',
            amount: -5.00,
            currencySymbol: 'CNY' // in this context, CNY will be passed as the currentSymbol argument in the currencyConversion function and get converted to USD (the primary-output symbol)
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
        }
    ],
    events: []
};

const reportController = {
    config: {
        name: 'some name', // optional but convenient
        mode: CONCISE
    },
    rules: [
        {
            type: STANDARD_OUTPUT
        },
        {
            name: 'some name', // optional but convenient
            type: AGGREGATES, // both type and aggregates properties are necessary
            aggregateRules: [
                {
                    name: 'some name', // optional but convenient
                    type:
                        SUMS_AND_AVERAGES ||
                        MINIMUMS_AND_MAXIMUMS ||
                        MEDIANS_AND_MODES ||
                        GREATEST_VALUES ||
                        LEAST_VALUES,
                    frequency: ANNUALLY || MONTHLY || WEEKLY || DAY_CYCLES || DATE_SETS,
                    propertyKey: 'balanceEnding' || 'amount', // determines the field that this aggregate will execute against
                    // note: flowKey/flowDirection filter the events prior to running computations
                    flowKey: 'balanceEnding', // when using flowDirection (below), this is the key that it checks against
                    flowDirection: POSITIVE || NEGATIVE || BOTH, // filters events that are either greater than or less than 0
                    // note: flowDirection/flowKey can be used on the reportController's config object and also in any particular report rule object, where the effects will be made  in each respective scope
                    sortKey: DEFAULT || SUM || AVERAGE || MEDIANS || MODES || MIN || MAX || 'any property key', // optional: be aware that medians and modes will not always sort accurately since there could be more than 1 median/mode for each aggregate
                    sortDirection: ASCENDING || DESCENDING, // optional: defaults to ASCENDING
                    selectionLimit: 5, // this property is only for GREATEST_VALUES || LEAST_VALUES; pass null for no selectionLimit
                    dateSets: ['2020-01-01', '2020-03-19', '2020-06-20', '2020-09-17'], // this property is required for DATE_SETS; this example will find aggregates between 2020-01-01 and 2020-03-19 and then between 2020-06-20 and 2020-09-17
                    modeMax: 3, // this property sets the limit for the amount of modes returned by MEDIANS_AND_MODES
                    xPercentRange: 0.1, // sets the percentage difference allowed for mode matches, specifically. Defaults to 0 which is 0% difference (exact match); 0.1 indicates 10%
                    // while xPercentRange defaults to 0, it is probably necessary to boost it to at least 0.01 or so as it might be common for you to otherwise get no mode matches at all
                    weekdayStart: SUNDAY, // this optional property allows you to adjust the starting weekday for WEEKLY aggregate types
                    dayCycles: 10, // when using the DAY_CYCLES type, you can choose how many cycles of days to aggregate against for each collection
                    cycleDateStart: '2020-09-17', // this optional property allows you to change the starting date for the DAY_CYCLES type
                    fiscalYearStart: '12-25' // this optional property allows you to change the starting date for the ANNUALLY type; the default value is the first of january
                }
            ]
        }
    ]
};

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2019-03-20',
        effectiveDateEnd: '2019-12-13',
        timeZone: 'US/Eastern', // the time zone in context of the observer that every rule will be converted to; see moment-timezone for a complete list time zones
        timeZoneType: LOCAL // LOCAL and UTC are available to be imported as constants
    },
    rules: [
        {
            // rule 1
            type: STANDARD_EVENT,
            frequency: DAILY,
            name: 'international video conference',
            amount: -20.0,
            effectiveDateStart: '2019-03-20',
            effectiveDateEnd: '2019-04-01',
            timeZone: 'Europe/Paris', // see immediately below for a time zone list
            timeStart: '11:00am',
            spanningMinutes: 30
        }
    ],
    events: [] // future balance projections stored here
};

// run the following for a complete list of time zones:
const moment = require('moment-timezone');
moment.tz.names().forEach(name => console.log(name);

const reportController = {
    config: {
        mode: CONCISE,
        file: {
            path: path.resolve(__dirname), // a path string; defaults to a "reports" directory four levels up from fileIo.js, but make sure that this reports directory exists!
            name: 'MyReport.txt',
            onFinish: () => {}, // optional
            onError: (err) => {}, // optional
            jsonSpacing: 4 // OPTIONAL! This is the default setting when using the rawJson attribute
        }
    },
    rules: [
        {
            name: 'All Events',
            type: STANDARD_OUTPUT,
            criticalThreshold: 500.0 // optional for STANDARD_OUTPUT, adding this property to a STANDARD_OUTPUT report type will force the execution of CRITICAL_SNAPSHOTS
        },
        {
            name: 'Largest Expenses',
            type: GREATEST_NEGATIVE_EVENT_FLOWS,
            selectionLimit: 10 // pass null for no selectionLimit
        }
    ]
};

// passing a non-null value for error will log it to the console and bypass all other report functionality
createReport({ danielSan, controller: reportController, error, originalDanielSan }); // the originalDanielSan is useful for passing the original unmodified danielSan reference to display irrelevant or retired rules.

const decimalFormatterCustom = (
    number,
    { minIntegerDigits, minDecimalDigits, maxDecimalDigits, locale, style, currency }
) => {
    /* return number formatted */
};
const reportController = {
    config: {
        name: 'some name',
        mode: CONCISE,
        // the formatting object is optional as the following values are defaulted for you
        // which will format amount, balanceBeginning, and balanceEnding
        formatting: {
            formattingFunction: decimalFormatterCustom,
            minIntegerDigits: 1,
            minDecimalDigits: 2,
            maxDecimalDigits: 2,
            locale: 'en-US',
            style: 'currency', // change to 'decimal' to remove the prepended currency symbol (if using the default formattingFunction)
            currency: 'USD'
        } // in addition, you can also pass formattingFunction into the formatting object above and all of the above parameters will be passed into that function call for you
    },
    rules: [
        {
            name: 'Sum of all Revenue',
            type: SUM_OF_ALL_POSITIVE_EVENT_FLOWS,
            criticalThreshold: 577.0 // optional for STANDARD_OUTPUT reports
        },
        {
            name: 'some name',
            type: STANDARD_OUTPUT,
            flowDirection: POSITIVE || NEGATIVE || BOTH, // eg. NEGATIVE will focus the computations on only expenses
        }
    ]
};

const waxOn = require('./rules'); // so we can use the word waxOn
const findBalance = require('daniel-san');
const createReport = require('daniel-san/reporting');

const eventResults = findBalance(waxOn.danielSan);
createReport({ danielSan: eventResults.danielSan, controller: reportController, error: eventResults.err }); // on err, the report's error logger will be executed instead of the event logger

const reportController = {
    config: {
        name: 'my report',
        mode: CONCISE,
        filterKeys: ['name', 'group'], 
        filterValues: ['rent', ANY], // the constant for ANY, INTERSECTION and UNION are available for import
        filterType: UNION || INTERSECTION, // event inclusion is governed by Any attributes that match || All attributes must match
        filterComparator: (filterKey, filterValue) => {
            // OPTIONAL! This is the default comparator
            return filterKey === filterValue;
        }   
    },
    rules: [
        {
            name: 'standard events',
            type: STANDARD_OUTPUT,
        }
    ]
};

const danielSan = {
    config: {
        balanceBeginning: 1618.03,
        effectiveDateStart: '2019-03-20',
        effectiveDateEnd: '2019-12-13'
    },
    rules: [
        { // rule 1
            name: 'monthly bitcoin investment',
            group: 'investments' // optional: assign a group category and filter the results with EVENTS_BY_GROUP
            amount: -79.83,
            type: STANDARD_EVENT,
            frequency: MONTHLY,
            processDate: '30',
            timeStart: '09:11am', // optional: assigning a timeStart attribute will order the event appropriately
            sortPriority: 25,   // optional: forces higher sort priority for event operations, the lower the sortPriority value,
                                // the sooner it is applied in the event sequence, (the processed event dates and timeStart take precedence over sortPriority)
            notes: 'some message to your future self', // optional
            important: true, // optional: assign important: true and filter the results with IMPORTANT_EVENTS
            effectiveDateStart: '2019-01-01',
            effectiveDateEnd: null,
            modulus: 1,
            cycle: 1
        }
    ],
    events: []
};

const reportController = {
    name: 'some name',
    type: [STANDARD_OUTPUT, DISPLAY, SUM_OF_ALL_NEGATIVE_EVENT_FLOWS],
    mode: CONCISE,
    // note: you can use outputRelay or the file options but you cannot use both
    outputRelay: (content, error) => {
        if (content) process.stdout.write(content);
    }, // if you do not want to use the terminal or the default file writing functionality, you can push each chunk to a readstream that pipes into a write stream, or do as you like;
    // null content indicates end of output "stream"
    // note: the 2nd paramter indicates whether or not the content is provided in the context of an error
    // note: when not using rawJson, each line of output is already formatted with a newline
    rawJson: false, // OPTIONAL! When set to true, each json chunk is either sent to outputRelay as content, or, if using the default file writing functionality, is output to a json file
    reportCharWidth: 89 // changes width of the print screen when not using the rawJson option
};

const {
    APP_NAME,
    AMOUNT,
    BALANCE_ENDING,
    DEFAULT_ERROR_MESSAGE,
    TIME_DELIMITER,
    DATE_TIME_DELIMITER,
    DATE_FORMAT_STRING,
    TIME_FORMAT_STRING,
    UTC,
    LOCAL,
    AM,
    PM,
    EVENT_SOURCE,
    OBSERVER_SOURCE,
    BOTH,
    ANY,
    UNION,
    INTERSECTION,
    POSITIVE,
    NEGATIVE,
    STANDARD_EVENT,
    STANDARD_EVENT_ROUTINE,
    STANDARD_EVENT_REMINDER,
    NTH_WEEKDAYS_OF_MONTH,
    NTH_WEEKDAYS_OF_MONTH_ROUTINE,
    NTH_WEEKDAYS_OF_MONTH_REMINDER,
    WEEKDAY_ON_DATE,
    WEEKDAY_ON_DATE_ROUTINE,
    WEEKDAY_ON_DATE_REMINDER,
    MOVE_THIS_PROCESS_DATE_BEFORE_THESE_WEEKDAYS,
    MOVE_THIS_PROCESS_DATE_BEFORE_THESE_DATES,
    PRE_PAY,
    MOVE_THIS_PROCESS_DATE_AFTER_THESE_WEEKDAYS,
    MOVE_THIS_PROCESS_DATE_AFTER_THESE_DATES,
    POST_PAY,
    ADJUST_AMOUNT_ON_THESE_DATES,
    ADJUST_AMOUNT,
    ANNUALLY,
    MONTHLY,
    WEEKLY,
    DAILY,
    ONCE,
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    WEEKENDS,
    STANDARD_OUTPUT,
    VERBOSE,
    CONCISE,
    SHY,
    EVENTS_BY_GROUP,
    EVENTS_BY_GROUPS,
    EVENTS_BY_NAME,
    EVENTS_BY_NAMES,
    EVENTS_BY_TYPE,
    EVENTS_BY_TYPES,
    EVENTS_BY_KEYS_AND_VALUES,
    EVENTS,
    CRITICAL_SNAPSHOTS,
    DISCARDED_EVENTS,
    IMPORTANT_EVENTS,
    TIME_EVENTS,
    ROUTINE,
    REMINDER,
    ROUTINE_EVENTS,
    REMINDER_EVENTS,
    ROUTINE_AND_REMINDER_EVENTS,
    RULES_TO_RETIRE,
    IRRELEVANT_RULES,
    SUM_OF_ALL_POSITIVE_EVENT_FLOWS,
    SUM_OF_ALL_POSITIVE_EVENT_AMOUNTS,
    SUM_OF_ALL_NEGATIVE_EVENT_FLOWS,
    SUM_OF_ALL_NEGATIVE_EVENT_AMOUNTS,
    EVENT_FLOWS_GREATER_THAN_TARGET,
    EVENT_FLOWS_LESS_THAN_TARGET,
    NEGATIVE_EVENT_FLOWS_GREATER_THAN_TARGET,
    NEGATIVE_EVENT_FLOWS_LESS_THAN_TARGET,
    POSITIVE_EVENT_FLOWS_GREATER_THAN_TARGET,
    POSITIVE_EVENT_FLOWS_LESS_THAN_TARGET,
    BALANCE_ENDING_SNAPSHOTS_GREATER_THAN_TARGET,
    BALANCE_ENDING_SNAPSHOTS_LESS_THAN_TARGET,
    GREATEST_BALANCE_ENDING_SNAPSHOTS,
    LEAST_BALANCE_ENDING_SNAPSHOTS,
    GREATEST_EVENT_FLOWS,
    LEAST_EVENT_FLOWS,
    GREATEST_POSITIVE_EVENT_FLOWS,
    LEAST_POSITIVE_EVENT_FLOWS,
    GREATEST_NEGATIVE_EVENT_FLOWS,
    LEAST_NEGATIVE_EVENT_FLOWS,
    EVENT_FLOWS_WITHIN_X_PERCENT_OF_TARGET,
    NEGATIVE_EVENT_FLOWS_WITHIN_X_PERCENT_OF_TARGET,
    POSITIVE_EVENT_FLOWS_WITHIN_X_PERCENT_OF_TARGET,
    BALANCE_ENDING_SNAPSHOTS_WITHIN_X_PERCENT_OF_TARGET,
    AGGREGATES,
    DAY_CYCLES,
    DATE_SETS,
    SUMS_AND_AVERAGES,
    MEDIANS_AND_MODES,
    MINIMUMS_AND_MAXIMUMS,
    GREATEST_VALUES,
    LEAST_VALUES,
    DEFAULT,
    ASCENDING,
    DESCENDING,
    SUM,
    AVERAGE,
    MEDIANS,
    MODES,
    MIN,
    MAX,
    MIN_INT_DIGITS_DEFAULT,
    MIN_DECIMAL_DIGITS_DEFAULT,
    MAX_DECIMAL_DIGITS_DEFAULT,
    LOCALE_DEFAULT,
    STYLE_DEFAULT,
    CURRENCY_DEFAULT,
    RULE,
    EVENT,
    REPORT,
    AGGREGATE,
    AGGREGATE_GROUP,
    DEFAULT_JSON_SPACING,
    DEFAULT_SELECTION_LIMIT
} = require('daniel-san/constants');