@mikemo-coposit/am-accounting-shared 1.0.7 → 1.0.9

package/dist/cjs/constants/common/package-version.constant.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.0.6";
+export declare const PACKAGE_VERSION = "1.0.9";
 //# sourceMappingURL=package-version.constant.d.ts.map

package/dist/cjs/index.cjs

@@ -310,6 +310,444 @@ var __webpack_modules__ = {
             this.emit('error', err);
         };
     },
+    "./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js": function(module, exports1, __webpack_require__) {
+        exports1.formatArgs = formatArgs;
+        exports1.save = save;
+        exports1.load = load;
+        exports1.useColors = useColors;
+        exports1.storage = localstorage();
+        exports1.destroy = (()=>{
+            let warned = false;
+            return ()=>{
+                if (!warned) {
+                    warned = true;
+                    console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+                }
+            };
+        })();
+        exports1.colors = [
+            '#0000CC',
+            '#0000FF',
+            '#0033CC',
+            '#0033FF',
+            '#0066CC',
+            '#0066FF',
+            '#0099CC',
+            '#0099FF',
+            '#00CC00',
+            '#00CC33',
+            '#00CC66',
+            '#00CC99',
+            '#00CCCC',
+            '#00CCFF',
+            '#3300CC',
+            '#3300FF',
+            '#3333CC',
+            '#3333FF',
+            '#3366CC',
+            '#3366FF',
+            '#3399CC',
+            '#3399FF',
+            '#33CC00',
+            '#33CC33',
+            '#33CC66',
+            '#33CC99',
+            '#33CCCC',
+            '#33CCFF',
+            '#6600CC',
+            '#6600FF',
+            '#6633CC',
+            '#6633FF',
+            '#66CC00',
+            '#66CC33',
+            '#9900CC',
+            '#9900FF',
+            '#9933CC',
+            '#9933FF',
+            '#99CC00',
+            '#99CC33',
+            '#CC0000',
+            '#CC0033',
+            '#CC0066',
+            '#CC0099',
+            '#CC00CC',
+            '#CC00FF',
+            '#CC3300',
+            '#CC3333',
+            '#CC3366',
+            '#CC3399',
+            '#CC33CC',
+            '#CC33FF',
+            '#CC6600',
+            '#CC6633',
+            '#CC9900',
+            '#CC9933',
+            '#CCCC00',
+            '#CCCC33',
+            '#FF0000',
+            '#FF0033',
+            '#FF0066',
+            '#FF0099',
+            '#FF00CC',
+            '#FF00FF',
+            '#FF3300',
+            '#FF3333',
+            '#FF3366',
+            '#FF3399',
+            '#FF33CC',
+            '#FF33FF',
+            '#FF6600',
+            '#FF6633',
+            '#FF9900',
+            '#FF9933',
+            '#FFCC00',
+            '#FFCC33'
+        ];
+        function useColors() {
+            if ('undefined' != typeof window && window.process && ('renderer' === window.process.type || window.process.__nwjs)) return true;
+            if ('undefined' != typeof navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) return false;
+            let m;
+            return 'undefined' != typeof document && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || 'undefined' != typeof window && window.console && (window.console.firebug || window.console.exception && window.console.table) || 'undefined' != typeof navigator && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || 'undefined' != typeof navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+        }
+        function formatArgs(args) {
+            args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
+            if (!this.useColors) return;
+            const c = 'color: ' + this.color;
+            args.splice(1, 0, c, 'color: inherit');
+            let index = 0;
+            let lastC = 0;
+            args[0].replace(/%[a-zA-Z%]/g, (match)=>{
+                if ('%%' === match) return;
+                index++;
+                if ('%c' === match) lastC = index;
+            });
+            args.splice(lastC, 0, c);
+        }
+        exports1.log = console.debug || console.log || (()=>{});
+        function save(namespaces) {
+            try {
+                if (namespaces) exports1.storage.setItem('debug', namespaces);
+                else exports1.storage.removeItem('debug');
+            } catch (error) {}
+        }
+        function load() {
+            let r;
+            try {
+                r = exports1.storage.getItem('debug') || exports1.storage.getItem('DEBUG');
+            } catch (error) {}
+            if (!r && 'undefined' != typeof process && 'env' in process) r = process.env.DEBUG;
+            return r;
+        }
+        function localstorage() {
+            try {
+                return localStorage;
+            } catch (error) {}
+        }
+        module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js")(exports1);
+        const { formatters } = module.exports;
+        formatters.j = function(v) {
+            try {
+                return JSON.stringify(v);
+            } catch (error) {
+                return '[UnexpectedJSONParseError]: ' + error.message;
+            }
+        };
+    },
+    "./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        function setup(env) {
+            createDebug.debug = createDebug;
+            createDebug.default = createDebug;
+            createDebug.coerce = coerce;
+            createDebug.disable = disable;
+            createDebug.enable = enable;
+            createDebug.enabled = enabled;
+            createDebug.humanize = __webpack_require__("./node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js");
+            createDebug.destroy = destroy;
+            Object.keys(env).forEach((key)=>{
+                createDebug[key] = env[key];
+            });
+            createDebug.names = [];
+            createDebug.skips = [];
+            createDebug.formatters = {};
+            function selectColor(namespace) {
+                let hash = 0;
+                for(let i = 0; i < namespace.length; i++){
+                    hash = (hash << 5) - hash + namespace.charCodeAt(i);
+                    hash |= 0;
+                }
+                return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+            }
+            createDebug.selectColor = selectColor;
+            function createDebug(namespace) {
+                let prevTime;
+                let enableOverride = null;
+                let namespacesCache;
+                let enabledCache;
+                function debug(...args) {
+                    if (!debug.enabled) return;
+                    const self1 = debug;
+                    const curr = Number(new Date());
+                    const ms = curr - (prevTime || curr);
+                    self1.diff = ms;
+                    self1.prev = prevTime;
+                    self1.curr = curr;
+                    prevTime = curr;
+                    args[0] = createDebug.coerce(args[0]);
+                    if ('string' != typeof args[0]) args.unshift('%O');
+                    let index = 0;
+                    args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format)=>{
+                        if ('%%' === match) return '%';
+                        index++;
+                        const formatter = createDebug.formatters[format];
+                        if ('function' == typeof formatter) {
+                            const val = args[index];
+                            match = formatter.call(self1, val);
+                            args.splice(index, 1);
+                            index--;
+                        }
+                        return match;
+                    });
+                    createDebug.formatArgs.call(self1, args);
+                    const logFn = self1.log || createDebug.log;
+                    logFn.apply(self1, args);
+                }
+                debug.namespace = namespace;
+                debug.useColors = createDebug.useColors();
+                debug.color = createDebug.selectColor(namespace);
+                debug.extend = extend;
+                debug.destroy = createDebug.destroy;
+                Object.defineProperty(debug, 'enabled', {
+                    enumerable: true,
+                    configurable: false,
+                    get: ()=>{
+                        if (null !== enableOverride) return enableOverride;
+                        if (namespacesCache !== createDebug.namespaces) {
+                            namespacesCache = createDebug.namespaces;
+                            enabledCache = createDebug.enabled(namespace);
+                        }
+                        return enabledCache;
+                    },
+                    set: (v)=>{
+                        enableOverride = v;
+                    }
+                });
+                if ('function' == typeof createDebug.init) createDebug.init(debug);
+                return debug;
+            }
+            function extend(namespace, delimiter) {
+                const newDebug = createDebug(this.namespace + (void 0 === delimiter ? ':' : delimiter) + namespace);
+                newDebug.log = this.log;
+                return newDebug;
+            }
+            function enable(namespaces) {
+                createDebug.save(namespaces);
+                createDebug.namespaces = namespaces;
+                createDebug.names = [];
+                createDebug.skips = [];
+                const split = ('string' == typeof namespaces ? namespaces : '').trim().replace(/\s+/g, ',').split(',').filter(Boolean);
+                for (const ns of split)if ('-' === ns[0]) createDebug.skips.push(ns.slice(1));
+                else createDebug.names.push(ns);
+            }
+            function matchesTemplate(search, template) {
+                let searchIndex = 0;
+                let templateIndex = 0;
+                let starIndex = -1;
+                let matchIndex = 0;
+                while(searchIndex < search.length)if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || '*' === template[templateIndex])) if ('*' === template[templateIndex]) {
+                    starIndex = templateIndex;
+                    matchIndex = searchIndex;
+                    templateIndex++;
+                } else {
+                    searchIndex++;
+                    templateIndex++;
+                }
+                else {
+                    if (-1 === starIndex) return false;
+                    templateIndex = starIndex + 1;
+                    matchIndex++;
+                    searchIndex = matchIndex;
+                }
+                while(templateIndex < template.length && '*' === template[templateIndex])templateIndex++;
+                return templateIndex === template.length;
+            }
+            function disable() {
+                const namespaces = [
+                    ...createDebug.names,
+                    ...createDebug.skips.map((namespace)=>'-' + namespace)
+                ].join(',');
+                createDebug.enable('');
+                return namespaces;
+            }
+            function enabled(name) {
+                for (const skip of createDebug.skips)if (matchesTemplate(name, skip)) return false;
+                for (const ns of createDebug.names)if (matchesTemplate(name, ns)) return true;
+                return false;
+            }
+            function coerce(val) {
+                if (val instanceof Error) return val.stack || val.message;
+                return val;
+            }
+            function destroy() {
+                console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+            }
+            createDebug.enable(createDebug.load());
+            return createDebug;
+        }
+        module.exports = setup;
+    },
+    "./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        if ('undefined' == typeof process || 'renderer' === process.type || true === process.browser || process.__nwjs) module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/browser.js");
+        else module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js");
+    },
+    "./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/node.js": function(module, exports1, __webpack_require__) {
+        const tty = __webpack_require__("tty");
+        const util = __webpack_require__("util");
+        exports1.init = init;
+        exports1.log = log;
+        exports1.formatArgs = formatArgs;
+        exports1.save = save;
+        exports1.load = load;
+        exports1.useColors = useColors;
+        exports1.destroy = util.deprecate(()=>{}, 'Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
+        exports1.colors = [
+            6,
+            2,
+            3,
+            4,
+            5,
+            1
+        ];
+        try {
+            const supportsColor = __webpack_require__("./node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js");
+            if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) exports1.colors = [
+                20,
+                21,
+                26,
+                27,
+                32,
+                33,
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                45,
+                56,
+                57,
+                62,
+                63,
+                68,
+                69,
+                74,
+                75,
+                76,
+                77,
+                78,
+                79,
+                80,
+                81,
+                92,
+                93,
+                98,
+                99,
+                112,
+                113,
+                128,
+                129,
+                134,
+                135,
+                148,
+                149,
+                160,
+                161,
+                162,
+                163,
+                164,
+                165,
+                166,
+                167,
+                168,
+                169,
+                170,
+                171,
+                172,
+                173,
+                178,
+                179,
+                184,
+                185,
+                196,
+                197,
+                198,
+                199,
+                200,
+                201,
+                202,
+                203,
+                204,
+                205,
+                206,
+                207,
+                208,
+                209,
+                214,
+                215,
+                220,
+                221
+            ];
+        } catch (error) {}
+        exports1.inspectOpts = Object.keys(process.env).filter((key)=>/^debug_/i.test(key)).reduce((obj, key)=>{
+            const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k)=>k.toUpperCase());
+            let val = process.env[key];
+            val = /^(yes|on|true|enabled)$/i.test(val) ? true : /^(no|off|false|disabled)$/i.test(val) ? false : 'null' === val ? null : Number(val);
+            obj[prop] = val;
+            return obj;
+        }, {});
+        function useColors() {
+            return 'colors' in exports1.inspectOpts ? Boolean(exports1.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+        }
+        function formatArgs(args) {
+            const { namespace: name, useColors } = this;
+            if (useColors) {
+                const c = this.color;
+                const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
+                const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+                args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+                args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
+            } else args[0] = getDate() + name + ' ' + args[0];
+        }
+        function getDate() {
+            if (exports1.inspectOpts.hideDate) return '';
+            return new Date().toISOString() + ' ';
+        }
+        function log(...args) {
+            return process.stderr.write(util.formatWithOptions(exports1.inspectOpts, ...args) + '\n');
+        }
+        function save(namespaces) {
+            if (namespaces) process.env.DEBUG = namespaces;
+            else delete process.env.DEBUG;
+        }
+        function load() {
+            return process.env.DEBUG;
+        }
+        function init(debug) {
+            debug.inspectOpts = {};
+            const keys = Object.keys(exports1.inspectOpts);
+            for(let i = 0; i < keys.length; i++)debug.inspectOpts[keys[i]] = exports1.inspectOpts[keys[i]];
+        }
+        module.exports = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/common.js")(exports1);
+        const { formatters } = module.exports;
+        formatters.o = function(v) {
+            this.inspectOpts.colors = this.useColors;
+            return util.inspect(v, this.inspectOpts).split('\n').map((str)=>str.trim()).join(' ');
+        };
+        formatters.O = function(v) {
+            this.inspectOpts.colors = this.useColors;
+            return util.inspect(v, this.inspectOpts);
+        };
+    },
     "./node_modules/.pnpm/delayed-stream@1.0.0/node_modules/delayed-stream/lib/delayed_stream.js": function(module, __unused_webpack_exports, __webpack_require__) {
         var Stream = __webpack_require__("stream").Stream;
         var util = __webpack_require__("util");
@@ -472,11 +910,7 @@ var __webpack_modules__ = {
         module.exports = function() {
             if (!debug) {
                 try {
-                    debug = __webpack_require__(Object(function() {
-                        var e = new Error("Cannot find module 'debug'");
-                        e.code = 'MODULE_NOT_FOUND';
-                        throw e;
-                    }()))("follow-redirects");
+                    debug = __webpack_require__("./node_modules/.pnpm/debug@4.4.3/node_modules/debug/src/index.js")("follow-redirects");
                 } catch (error) {}
                 if ("function" != typeof debug) debug = function() {};
             }
@@ -1711,6 +2145,15 @@ var __webpack_modules__ = {
         }
         module.exports = $gOPD;
     },
+    "./node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js": function(module) {
+        "use strict";
+        module.exports = (flag, argv = process.argv)=>{
+            const prefix = flag.startsWith('-') ? '' : 1 === flag.length ? '-' : '--';
+            const position = argv.indexOf(prefix + flag);
+            const terminatorPosition = argv.indexOf('--');
+            return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
+        };
+    },
     "./node_modules/.pnpm/has-symbols@1.1.0/node_modules/has-symbols/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         "use strict";
         var origSymbol = 'undefined' != typeof Symbol && Symbol;
@@ -1885,6 +2328,91 @@ var __webpack_modules__ = {
             });
         }
     },
+    "./node_modules/.pnpm/ms@2.1.3/node_modules/ms/index.js": function(module) {
+        var s = 1000;
+        var m = 60 * s;
+        var h = 60 * m;
+        var d = 24 * h;
+        var w = 7 * d;
+        var y = 365.25 * d;
+        module.exports = function(val, options) {
+            options = options || {};
+            var type = typeof val;
+            if ('string' === type && val.length > 0) return parse(val);
+            if ('number' === type && isFinite(val)) return options.long ? fmtLong(val) : fmtShort(val);
+            throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val));
+        };
+        function parse(str) {
+            str = String(str);
+            if (str.length > 100) return;
+            var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+            if (!match) return;
+            var n = parseFloat(match[1]);
+            var type = (match[2] || 'ms').toLowerCase();
+            switch(type){
+                case 'years':
+                case 'year':
+                case 'yrs':
+                case 'yr':
+                case 'y':
+                    return n * y;
+                case 'weeks':
+                case 'week':
+                case 'w':
+                    return n * w;
+                case 'days':
+                case 'day':
+                case 'd':
+                    return n * d;
+                case 'hours':
+                case 'hour':
+                case 'hrs':
+                case 'hr':
+                case 'h':
+                    return n * h;
+                case 'minutes':
+                case 'minute':
+                case 'mins':
+                case 'min':
+                case 'm':
+                    return n * m;
+                case 'seconds':
+                case 'second':
+                case 'secs':
+                case 'sec':
+                case 's':
+                    return n * s;
+                case 'milliseconds':
+                case 'millisecond':
+                case 'msecs':
+                case 'msec':
+                case 'ms':
+                    return n;
+                default:
+                    return;
+            }
+        }
+        function fmtShort(ms) {
+            var msAbs = Math.abs(ms);
+            if (msAbs >= d) return Math.round(ms / d) + 'd';
+            if (msAbs >= h) return Math.round(ms / h) + 'h';
+            if (msAbs >= m) return Math.round(ms / m) + 'm';
+            if (msAbs >= s) return Math.round(ms / s) + 's';
+            return ms + 'ms';
+        }
+        function fmtLong(ms) {
+            var msAbs = Math.abs(ms);
+            if (msAbs >= d) return plural(ms, msAbs, d, 'day');
+            if (msAbs >= h) return plural(ms, msAbs, h, 'hour');
+            if (msAbs >= m) return plural(ms, msAbs, m, 'minute');
+            if (msAbs >= s) return plural(ms, msAbs, s, 'second');
+            return ms + ' ms';
+        }
+        function plural(ms, msAbs, n, name) {
+            var isPlural = msAbs >= 1.5 * n;
+            return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+        }
+    },
     "./node_modules/.pnpm/proxy-from-env@1.1.0/node_modules/proxy-from-env/index.js": function(__unused_webpack_module, exports1, __webpack_require__) {
         "use strict";
         var parseUrl = __webpack_require__("url").parse;
@@ -1933,6 +2461,74 @@ var __webpack_modules__ = {
         }
         exports1.getProxyForUrl = getProxyForUrl;
     },
+    "./node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const os = __webpack_require__("os");
+        const tty = __webpack_require__("tty");
+        const hasFlag = __webpack_require__("./node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js");
+        const { env } = process;
+        let forceColor;
+        if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) forceColor = 0;
+        else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) forceColor = 1;
+        if ('FORCE_COLOR' in env) forceColor = 'true' === env.FORCE_COLOR ? 1 : 'false' === env.FORCE_COLOR ? 0 : 0 === env.FORCE_COLOR.length ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+        function translateLevel(level) {
+            if (0 === level) return false;
+            return {
+                level,
+                hasBasic: true,
+                has256: level >= 2,
+                has16m: level >= 3
+            };
+        }
+        function supportsColor(haveStream, streamIsTTY) {
+            if (0 === forceColor) return 0;
+            if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) return 3;
+            if (hasFlag('color=256')) return 2;
+            if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
+            const min = forceColor || 0;
+            if ('dumb' === env.TERM) return min;
+            if ('win32' === process.platform) {
+                const osRelease = os.release().split('.');
+                if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+                return 1;
+            }
+            if ('CI' in env) {
+                if ([
+                    'TRAVIS',
+                    'CIRCLECI',
+                    'APPVEYOR',
+                    'GITLAB_CI',
+                    'GITHUB_ACTIONS',
+                    'BUILDKITE'
+                ].some((sign)=>sign in env) || 'codeship' === env.CI_NAME) return 1;
+                return min;
+            }
+            if ('TEAMCITY_VERSION' in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+            if ('truecolor' === env.COLORTERM) return 3;
+            if ('TERM_PROGRAM' in env) {
+                const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+                switch(env.TERM_PROGRAM){
+                    case 'iTerm.app':
+                        return version >= 3 ? 3 : 2;
+                    case 'Apple_Terminal':
+                        return 2;
+                }
+            }
+            if (/-256(color)?$/i.test(env.TERM)) return 2;
+            if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+            if ('COLORTERM' in env) return 1;
+            return min;
+        }
+        function getSupportLevel(stream) {
+            const level = supportsColor(stream, stream && stream.isTTY);
+            return translateLevel(level);
+        }
+        module.exports = {
+            supportsColor: getSupportLevel,
+            stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+            stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+        };
+    },
     assert: function(module) {
         "use strict";
         module.exports = require("assert");
@@ -1953,6 +2549,10 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = require("https");
     },
+    os: function(module) {
+        "use strict";
+        module.exports = require("os");
+    },
     path: function(module) {
         "use strict";
         module.exports = require("path");
@@ -1961,6 +2561,10 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = require("stream");
     },
+    tty: function(module) {
+        "use strict";
+        module.exports = require("tty");
+    },
     url: function(module) {
         "use strict";
         module.exports = require("url");
@@ -2253,7 +2857,7 @@ var __webpack_exports__ = {};
         MtaTransactionPaymentMethod: ()=>mta_payment_method_constant_MtaTransactionPaymentMethod,
         JsonNullableFilterSchema: ()=>JsonNullableFilterSchema,
         stringToEndOfDaySchema: ()=>stringToEndOfDaySchema,
-        PACKAGE_VERSION: ()=>"1.0.6",
+        PACKAGE_VERSION: ()=>"1.0.9",
         createSettlementPayoutRestReqSchema: ()=>createSettlementPayoutRestReqSchema,
         DEFAULT_PAYOUT_TARGET_BANK_REF: ()=>DEFAULT_PAYOUT_TARGET_BANK_REF,
         CmaTransactionStatus: ()=>CmaTransactionStatus,
@@ -3273,7 +3877,7 @@ var __webpack_exports__ = {};
             external_zod_namespaceObject.z.coerce.bigint(),
             external_zod_namespaceObject.z.coerce.number()
         ]).pipe(external_zod_namespaceObject.z.bigint()),
-        isCmaRequired: external_zod_namespaceObject.z.boolean(),
+        isCmaRequired: external_zod_namespaceObject.z.boolean().prefault(true).default(true),
         cmaNotRequiredReason: external_zod_namespaceObject.z.string().nullish(),
         stage: external_zod_namespaceObject.z.string(),
         status: external_zod_namespaceObject.z.string(),
@@ -4560,7 +5164,7 @@ var __webpack_exports__ = {};
     });
     const mtaToCmaPayoutSourceDetailRestSchema = mtaToCmaPayoutSourceDetailEntitySchema.extend({
         debitAmountCents: centsToDollarsSchema,
-        property: external_zod_namespaceObject.z.lazy(()=>propertyRestResBaseSchema).nullish(),
+        property: external_zod_namespaceObject.z.lazy(()=>propertyRestResBaseSchema.partial()).nullish(),
         mtaTransaction: external_zod_namespaceObject.z.lazy(()=>mtaTransactionRestResSchema).nullish()
     }).loose();
     const mtaToCmaPayoutTargetDetailRestSchema = mtaToCmaPayoutTargetDetailEntitySchema.extend({