npm - @mikemo-coposit/am-accounting-shared - Versions diffs - 1.2.0 → 1.2.2 - Mend

@mikemo-coposit/am-accounting-shared 1.2.0 → 1.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

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

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

package/dist/cjs/index.cjs CHANGED Viewed

@@ -1,4 +1,4 @@
-/*! For license information please see index.cjs.LICENSE.txt */
+/*! LICENSE: index.cjs.LICENSE.txt */
 var __webpack_modules__ = {
     "./node_modules/.pnpm/asynckit@0.4.0/node_modules/asynckit/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         module.exports = {
@@ -2408,54 +2408,6 @@ var __webpack_modules__ = {
             return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
         }
     },
-    "./node_modules/.pnpm/proxy-from-env@1.1.0/node_modules/proxy-from-env/index.js" (__unused_rspack_module, exports1, __webpack_require__) {
-        "use strict";
-        var parseUrl = __webpack_require__("url").parse;
-        var DEFAULT_PORTS = {
-            ftp: 21,
-            gopher: 70,
-            http: 80,
-            https: 443,
-            ws: 80,
-            wss: 443
-        };
-        var stringEndsWith = String.prototype.endsWith || function(s) {
-            return s.length <= this.length && -1 !== this.indexOf(s, this.length - s.length);
-        };
-        function getProxyForUrl(url) {
-            var parsedUrl = 'string' == typeof url ? parseUrl(url) : url || {};
-            var proto = parsedUrl.protocol;
-            var hostname = parsedUrl.host;
-            var port = parsedUrl.port;
-            if ('string' != typeof hostname || !hostname || 'string' != typeof proto) return '';
-            proto = proto.split(':', 1)[0];
-            hostname = hostname.replace(/:\d*$/, '');
-            port = parseInt(port) || DEFAULT_PORTS[proto] || 0;
-            if (!shouldProxy(hostname, port)) return '';
-            var proxy = getEnv('npm_config_' + proto + '_proxy') || getEnv(proto + '_proxy') || getEnv('npm_config_proxy') || getEnv('all_proxy');
-            if (proxy && -1 === proxy.indexOf('://')) proxy = proto + '://' + proxy;
-            return proxy;
-        }
-        function shouldProxy(hostname, port) {
-            var NO_PROXY = (getEnv('npm_config_no_proxy') || getEnv('no_proxy')).toLowerCase();
-            if (!NO_PROXY) return true;
-            if ('*' === NO_PROXY) return false;
-            return NO_PROXY.split(/[,\s]/).every(function(proxy) {
-                if (!proxy) return true;
-                var parsedProxy = proxy.match(/^(.+):(\d+)$/);
-                var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
-                var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
-                if (parsedProxyPort && parsedProxyPort !== port) return true;
-                if (!/^[.*]/.test(parsedProxyHostname)) return hostname !== parsedProxyHostname;
-                if ('*' === parsedProxyHostname.charAt(0)) parsedProxyHostname = parsedProxyHostname.slice(1);
-                return !stringEndsWith.call(hostname, parsedProxyHostname);
-            });
-        }
-        function getEnv(key) {
-            return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';
-        }
-        exports1.getProxyForUrl = getProxyForUrl;
-    },
     assert (module) {
         "use strict";
         module.exports = require("assert");
@@ -2657,6 +2609,7 @@ var __webpack_exports__ = {};
         maskString: ()=>maskString,
         balanceRestResSchema: ()=>balanceRestResSchema,
         cmaAccountPeriodRestResSchema: ()=>cmaAccountPeriodRestResSchema,
+        buyerLedgerRestReqBaseSchema: ()=>buyerLedgerRestReqBaseSchema,
         getTransactionNumber: ()=>getTransactionNumber,
         PayoutType: ()=>PayoutType,
         intFilterSchema: ()=>intFilterSchema,
@@ -2802,7 +2755,7 @@ var __webpack_exports__ = {};
         MtaTransactionPaymentMethod: ()=>mta_payment_method_constant_MtaTransactionPaymentMethod,
         JsonNullableFilterSchema: ()=>JsonNullableFilterSchema,
         stringToEndOfDaySchema: ()=>stringToEndOfDaySchema,
-        PACKAGE_VERSION: ()=>"1.2.0",
+        PACKAGE_VERSION: ()=>"1.2.1",
         createSettlementPayoutRestReqSchema: ()=>createSettlementPayoutRestReqSchema,
         DEFAULT_PAYOUT_TARGET_BANK_REF: ()=>DEFAULT_PAYOUT_TARGET_BANK_REF,
         CmaTransactionStatus: ()=>CmaTransactionStatus,
@@ -3471,6 +3424,10 @@ var __webpack_exports__ = {};
             external_zod_namespaceObject.z.lazy(()=>stringFilterSchema),
             external_zod_namespaceObject.z.string()
         ]).optional(),
+        accountNumber: external_zod_namespaceObject.z.union([
+            external_zod_namespaceObject.z.lazy(()=>stringFilterSchema),
+            external_zod_namespaceObject.z.string()
+        ]).optional(),
         country: external_zod_namespaceObject.z.union([
             external_zod_namespaceObject.z.lazy(()=>stringFilterSchema),
             external_zod_namespaceObject.z.string()
@@ -5764,10 +5721,37 @@ var __webpack_exports__ = {};
         });
     });
     const bankReconciliationSummaryRestReqSchema = commonReportWithCmaSelectionRestReqSchema;
-    const buyerLedgerRestReqSchema = commonReportRestReqSchema.and(external_zod_namespaceObject.z.object({
+    const buyerLedgerRestReqBaseSchema = commonReportRestReqSchema.and(external_zod_namespaceObject.z.object({
         propertyIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.uuid()).min(1),
-        reportGroupType: external_zod_namespaceObject.z["enum"](report_group_type_constant_ReportGroupType)
+        reportGroupType: external_zod_namespaceObject.z["enum"](report_group_type_constant_ReportGroupType),
+        showMta: external_zod_namespaceObject.z.boolean().default(true),
+        showCma: external_zod_namespaceObject.z.boolean().default(true),
+        mtaTransactionTypes: external_zod_namespaceObject.z["enum"](MtaTransactionType).array().optional(),
+        cmaTransactionTypes: external_zod_namespaceObject.z["enum"](CmaTransactionType).array().optional()
     }));
+    const buyerLedgerRestReqSchema = buyerLedgerRestReqBaseSchema.superRefine((data, ctx)=>{
+        if (!data.showMta && !data.showCma) ctx.addIssue({
+            code: "custom",
+            message: "At least one of MTA or CMA must be selected",
+            path: [
+                "showMta"
+            ]
+        });
+        if (data.showMta && (!data.mtaTransactionTypes || 0 === data.mtaTransactionTypes.length)) ctx.addIssue({
+            code: "custom",
+            message: "Select at least one MTA transaction type",
+            path: [
+                "mtaTransactionTypes"
+            ]
+        });
+        if (data.showCma && (!data.cmaTransactionTypes || 0 === data.cmaTransactionTypes.length)) ctx.addIssue({
+            code: "custom",
+            message: "Select at least one CMA transaction type",
+            path: [
+                "cmaTransactionTypes"
+            ]
+        });
+    });
     const paymentListReportRestReqSchema = commonReportRestReqSchema.and(external_zod_namespaceObject.z.object({
         accountId: external_zod_namespaceObject.z.uuid(),
         accountType: external_zod_namespaceObject.z["enum"](account_type_constant_AccountType)
@@ -6622,12 +6606,27 @@ var __webpack_exports__ = {};
         return parsed;
     };
     const $internals = Symbol('internals');
+    const isValidHeaderValue = (value)=>!/[\r\n]/.test(value);
+    function assertValidHeaderValue(value, header) {
+        if (false === value || null == value) return;
+        if (utils.isArray(value)) return void value.forEach((v)=>assertValidHeaderValue(v, header));
+        if (!isValidHeaderValue(String(value))) throw new Error(`Invalid character in header content ["${header}"]`);
+    }
     function normalizeHeader(header) {
         return header && String(header).trim().toLowerCase();
     }
+    function stripTrailingCRLF(str) {
+        let end = str.length;
+        while(end > 0){
+            const charCode = str.charCodeAt(end - 1);
+            if (10 !== charCode && 13 !== charCode) break;
+            end -= 1;
+        }
+        return end === str.length ? str : str.slice(0, end);
+    }
     function normalizeValue(value) {
         if (false === value || null == value) return value;
-        return utils.isArray(value) ? value.map(normalizeValue) : String(value);
+        return utils.isArray(value) ? value.map(normalizeValue) : stripTrailingCRLF(String(value));
     }
     function parseTokens(str) {
         const tokens = Object.create(null);
@@ -6672,7 +6671,10 @@ var __webpack_exports__ = {};
                 const lHeader = normalizeHeader(_header);
                 if (!lHeader) throw new Error('header name must be a non-empty string');
                 const key = utils.findKey(self1, lHeader);
-                if (!key || void 0 === self1[key] || true === _rewrite || void 0 === _rewrite && false !== self1[key]) self1[key || _header] = normalizeValue(_value);
+                if (!key || void 0 === self1[key] || true === _rewrite || void 0 === _rewrite && false !== self1[key]) {
+                    assertValidHeaderValue(_value, _header);
+                    self1[key || _header] = normalizeValue(_value);
+                }
             }
             const setHeaders = (headers, _rewrite)=>utils.forEach(headers, (_value, _header)=>setHeader(_value, _header, _rewrite));
             if (utils.isPlainObject(header) || header instanceof this.constructor) setHeaders(header, valueOrRewrite);
@@ -6870,7 +6872,53 @@ var __webpack_exports__ = {};
         if (baseURL && (isRelativeUrl || false == allowAbsoluteUrls)) return combineURLs(baseURL, requestedURL);
         return requestedURL;
     }
-    var proxy_from_env = __webpack_require__("./node_modules/.pnpm/proxy-from-env@1.1.0/node_modules/proxy-from-env/index.js");
+    var DEFAULT_PORTS = {
+        ftp: 21,
+        gopher: 70,
+        http: 80,
+        https: 443,
+        ws: 80,
+        wss: 443
+    };
+    function parseUrl(urlString) {
+        try {
+            return new URL(urlString);
+        } catch  {
+            return null;
+        }
+    }
+    function getProxyForUrl(url) {
+        var parsedUrl = ('string' == typeof url ? parseUrl(url) : url) || {};
+        var proto = parsedUrl.protocol;
+        var hostname = parsedUrl.host;
+        var port = parsedUrl.port;
+        if ('string' != typeof hostname || !hostname || 'string' != typeof proto) return '';
+        proto = proto.split(':', 1)[0];
+        hostname = hostname.replace(/:\d*$/, '');
+        port = parseInt(port) || DEFAULT_PORTS[proto] || 0;
+        if (!shouldProxy(hostname, port)) return '';
+        var proxy = getEnv(proto + '_proxy') || getEnv('all_proxy');
+        if (proxy && -1 === proxy.indexOf('://')) proxy = proto + '://' + proxy;
+        return proxy;
+    }
+    function shouldProxy(hostname, port) {
+        var NO_PROXY = getEnv('no_proxy').toLowerCase();
+        if (!NO_PROXY) return true;
+        if ('*' === NO_PROXY) return false;
+        return NO_PROXY.split(/[,\s]/).every(function(proxy) {
+            if (!proxy) return true;
+            var parsedProxy = proxy.match(/^(.+):(\d+)$/);
+            var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
+            var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
+            if (parsedProxyPort && parsedProxyPort !== port) return true;
+            if (!/^[.*]/.test(parsedProxyHostname)) return hostname !== parsedProxyHostname;
+            if ('*' === parsedProxyHostname.charAt(0)) parsedProxyHostname = parsedProxyHostname.slice(1);
+            return !hostname.endsWith(parsedProxyHostname);
+        });
+    }
+    function getEnv(key) {
+        return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || '';
+    }
     var external_http_ = __webpack_require__("http");
     var external_https_ = __webpack_require__("https");
     const external_http2_namespaceObject = require("http2");
@@ -7101,6 +7149,67 @@ var __webpack_exports__ = {};
             }, cb);
         } : fn;
     const helpers_callbackify = callbackify;
+    const shouldBypassProxy_DEFAULT_PORTS = {
+        http: 80,
+        https: 443,
+        ws: 80,
+        wss: 443,
+        ftp: 21
+    };
+    const parseNoProxyEntry = (entry)=>{
+        let entryHost = entry;
+        let entryPort = 0;
+        if ('[' === entryHost.charAt(0)) {
+            const bracketIndex = entryHost.indexOf(']');
+            if (-1 !== bracketIndex) {
+                const host = entryHost.slice(1, bracketIndex);
+                const rest = entryHost.slice(bracketIndex + 1);
+                if (':' === rest.charAt(0) && /^\d+$/.test(rest.slice(1))) entryPort = Number.parseInt(rest.slice(1), 10);
+                return [
+                    host,
+                    entryPort
+                ];
+            }
+        }
+        const firstColon = entryHost.indexOf(':');
+        const lastColon = entryHost.lastIndexOf(':');
+        if (-1 !== firstColon && firstColon === lastColon && /^\d+$/.test(entryHost.slice(lastColon + 1))) {
+            entryPort = Number.parseInt(entryHost.slice(lastColon + 1), 10);
+            entryHost = entryHost.slice(0, lastColon);
+        }
+        return [
+            entryHost,
+            entryPort
+        ];
+    };
+    const normalizeNoProxyHost = (hostname)=>{
+        if (!hostname) return hostname;
+        if ('[' === hostname.charAt(0) && ']' === hostname.charAt(hostname.length - 1)) hostname = hostname.slice(1, -1);
+        return hostname.replace(/\.+$/, '');
+    };
+    function shouldBypassProxy(location) {
+        let parsed;
+        try {
+            parsed = new URL(location);
+        } catch (_err) {
+            return false;
+        }
+        const noProxy = (process.env.no_proxy || process.env.NO_PROXY || '').toLowerCase();
+        if (!noProxy) return false;
+        if ('*' === noProxy) return true;
+        const port = Number.parseInt(parsed.port, 10) || shouldBypassProxy_DEFAULT_PORTS[parsed.protocol.split(':', 1)[0]] || 0;
+        const hostname = normalizeNoProxyHost(parsed.hostname.toLowerCase());
+        return noProxy.split(/[\s,]+/).some((entry)=>{
+            if (!entry) return false;
+            let [entryHost, entryPort] = parseNoProxyEntry(entry);
+            entryHost = normalizeNoProxyHost(entryHost);
+            if (!entryHost) return false;
+            if (entryPort && entryPort !== port) return false;
+            if ('*' === entryHost.charAt(0)) entryHost = entryHost.slice(1);
+            if ('.' === entryHost.charAt(0)) return hostname.endsWith(entryHost);
+            return hostname === entryHost;
+        });
+    }
     function speedometer(samplesCount, min) {
         samplesCount = samplesCount || 10;
         const bytes = new Array(samplesCount);
@@ -7281,6 +7390,7 @@ var __webpack_exports__ = {};
                 while(i--)if (entries[i][0] === session) {
                     if (1 === len) delete this.sessions[authority];
                     else entries.splice(i, 1);
+                    if (!session.closed) session.close();
                     return;
                 }
             };
@@ -7324,8 +7434,10 @@ var __webpack_exports__ = {};
     function setProxy(options, configProxy, location) {
         let proxy = configProxy;
         if (!proxy && false !== proxy) {
-            const proxyUrl = proxy_from_env.getProxyForUrl(location);
-            if (proxyUrl) proxy = new URL(proxyUrl);
+            const proxyUrl = getProxyForUrl(location);
+            if (proxyUrl) {
+                if (!shouldBypassProxy(location)) proxy = new URL(proxyUrl);
+            }
         }
         if (proxy) {
             if (proxy.username) proxy.auth = (proxy.username || '') + ':' + (proxy.password || '');
@@ -7503,7 +7615,7 @@ var __webpack_exports__ = {};
             }
             if (-1 === supportedProtocols.indexOf(protocol)) return reject(new core_AxiosError('Unsupported protocol ' + protocol, core_AxiosError.ERR_BAD_REQUEST, config));
             const headers = core_AxiosHeaders.from(config.headers).normalize();
-            headers.set('User-Agent', "axios/1.13.6", false);
+            headers.set('User-Agent', "axios/1.15.0", false);
             const { onUploadProgress, onDownloadProgress } = config;
             const maxRate = config.maxRate;
             let maxUploadRate;
@@ -7513,7 +7625,7 @@ var __webpack_exports__ = {};
                 data = helpers_formDataToStream(data, (formHeaders)=>{
                     headers.set(formHeaders);
                 }, {
-                    tag: "axios-1.13.6-boundary",
+                    tag: "axios-1.15.0-boundary",
                     boundary: userBoundary && userBoundary[1] || void 0
                 });
             } else if (utils.isFormData(data) && utils.isFunction(data.getHeaders)) {
@@ -8096,14 +8208,16 @@ var __webpack_exports__ = {};
         const encodeText = isFetchSupported && ('function' == typeof fetch_TextEncoder ? ((encoder)=>(str)=>encoder.encode(str))(new fetch_TextEncoder()) : async (str)=>new Uint8Array(await new Request(str).arrayBuffer()));
         const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(()=>{
             let duplexAccessed = false;
+            const body = new fetch_ReadableStream();
             const hasContentType = new Request(platform.origin, {
-                body: new fetch_ReadableStream(),
+                body,
                 method: 'POST',
                 get duplex () {
                     duplexAccessed = true;
                     return 'half';
                 }
             }).headers.has('Content-Type');
+            body.cancel();
             return duplexAccessed && !hasContentType;
         });
         const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(()=>utils.isReadableStream(new Response('').body));
@@ -8338,7 +8452,7 @@ var __webpack_exports__ = {};
     const deprecatedWarnings = {};
     validators.transitional = function(validator, version, message) {
         function formatMessage(opt, desc) {
-            return "[Axios v1.13.6] Transitional option '" + opt + "'" + desc + (message ? '. ' + message : '');
+            return "[Axios v1.15.0] Transitional option '" + opt + "'" + desc + (message ? '. ' + message : '');
         }
         return (value, opt, opts)=>{
             if (false === validator) throw new core_AxiosError(formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')), core_AxiosError.ERR_DEPRECATED);
@@ -8391,10 +8505,19 @@ var __webpack_exports__ = {};
                 if (err instanceof Error) {
                     let dummy = {};
                     Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error();
-                    const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : '';
+                    const stack = (()=>{
+                        if (!dummy.stack) return '';
+                        const firstNewlineIndex = dummy.stack.indexOf('\n');
+                        return -1 === firstNewlineIndex ? '' : dummy.stack.slice(firstNewlineIndex + 1);
+                    })();
                     try {
                         if (err.stack) {
-                            if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ''))) err.stack += '\n' + stack;
+                            if (stack) {
+                                const firstNewlineIndex = stack.indexOf('\n');
+                                const secondNewlineIndex = -1 === firstNewlineIndex ? -1 : stack.indexOf('\n', firstNewlineIndex + 1);
+                                const stackWithoutTwoTopLines = -1 === secondNewlineIndex ? '' : stack.slice(secondNewlineIndex + 1);
+                                if (!String(err.stack).endsWith(stackWithoutTwoTopLines)) err.stack += '\n' + stack;
+                            }
                         } else err.stack = stack;
                     } catch (e) {}
                 }
@@ -8703,7 +8826,7 @@ var __webpack_exports__ = {};
     axios.CanceledError = cancel_CanceledError;
     axios.CancelToken = cancel_CancelToken;
     axios.isCancel = isCancel;
-    axios.VERSION = "1.13.6";
+    axios.VERSION = "1.15.0";
     axios.toFormData = helpers_toFormData;
     axios.AxiosError = core_AxiosError;
     axios.Cancel = axios.CanceledError;
@@ -8948,6 +9071,7 @@ exports.bigIntObjectFilterSchema = __webpack_exports__.bigIntObjectFilterSchema;
 exports.bigIntSimpleFilterSchema = __webpack_exports__.bigIntSimpleFilterSchema;
 exports.boolFilterBaseSchema = __webpack_exports__.boolFilterBaseSchema;
 exports.boolFilterSchema = __webpack_exports__.boolFilterSchema;
+exports.buyerLedgerRestReqBaseSchema = __webpack_exports__.buyerLedgerRestReqBaseSchema;
 exports.buyerLedgerRestReqSchema = __webpack_exports__.buyerLedgerRestReqSchema;
 exports.cancelCmaTransactionRestReqSchema = __webpack_exports__.cancelCmaTransactionRestReqSchema;
 exports.cancelMtaTransactionRestReqSchema = __webpack_exports__.cancelMtaTransactionRestReqSchema;
@@ -9254,6 +9378,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "bigIntSimpleFilterSchema",
     "boolFilterBaseSchema",
     "boolFilterSchema",
+    "buyerLedgerRestReqBaseSchema",
     "buyerLedgerRestReqSchema",
     "cancelCmaTransactionRestReqSchema",
     "cancelMtaTransactionRestReqSchema",

package/dist/cjs/schemas/cma/cma-search.rest.schemal.d.ts CHANGED Viewed

@@ -56,6 +56,34 @@ export declare const cmaSearchRestReqBaseSchema: z.ZodObject<{
             endsWith: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>]>>;
     }, z.core.$strict>>, z.ZodString]>>;
+    accountNumber: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
+        equals: z.ZodOptional<z.ZodString>;
+        in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        lt: z.ZodOptional<z.ZodString>;
+        lte: z.ZodOptional<z.ZodString>;
+        gt: z.ZodOptional<z.ZodString>;
+        gte: z.ZodOptional<z.ZodString>;
+        contains: z.ZodOptional<z.ZodString>;
+        startsWith: z.ZodOptional<z.ZodString>;
+        endsWith: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodPrefault<z.ZodLazy<z.ZodEnum<{
+            readonly DEFAULT: "default";
+            readonly INSENSITIVE: "insensitive";
+        }>>>>;
+        not: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodObject<{
+            equals: z.ZodOptional<z.ZodString>;
+            in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            lt: z.ZodOptional<z.ZodString>;
+            lte: z.ZodOptional<z.ZodString>;
+            gt: z.ZodOptional<z.ZodString>;
+            gte: z.ZodOptional<z.ZodString>;
+            contains: z.ZodOptional<z.ZodString>;
+            startsWith: z.ZodOptional<z.ZodString>;
+            endsWith: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>>;
+    }, z.core.$strict>>, z.ZodString]>>;
     country: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
         equals: z.ZodOptional<z.ZodString>;
         in: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -895,6 +923,34 @@ export declare const cmaSearchRestReqSchema: z.ZodObject<{
             endsWith: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>]>>;
     }, z.core.$strict>>, z.ZodString]>>;
+    accountNumber: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
+        equals: z.ZodOptional<z.ZodString>;
+        in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        lt: z.ZodOptional<z.ZodString>;
+        lte: z.ZodOptional<z.ZodString>;
+        gt: z.ZodOptional<z.ZodString>;
+        gte: z.ZodOptional<z.ZodString>;
+        contains: z.ZodOptional<z.ZodString>;
+        startsWith: z.ZodOptional<z.ZodString>;
+        endsWith: z.ZodOptional<z.ZodString>;
+        mode: z.ZodOptional<z.ZodPrefault<z.ZodLazy<z.ZodEnum<{
+            readonly DEFAULT: "default";
+            readonly INSENSITIVE: "insensitive";
+        }>>>>;
+        not: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodObject<{
+            equals: z.ZodOptional<z.ZodString>;
+            in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            lt: z.ZodOptional<z.ZodString>;
+            lte: z.ZodOptional<z.ZodString>;
+            gt: z.ZodOptional<z.ZodString>;
+            gte: z.ZodOptional<z.ZodString>;
+            contains: z.ZodOptional<z.ZodString>;
+            startsWith: z.ZodOptional<z.ZodString>;
+            endsWith: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>>;
+    }, z.core.$strict>>, z.ZodString]>>;
     country: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
         equals: z.ZodOptional<z.ZodString>;
         in: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/cjs/schemas/cma/cma-search.rest.schemal.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"cma-search.rest.schemal.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/cma/cma-search.rest.schemal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWrC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
1	+ {"version":3,"file":"cma-search.rest.schemal.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/cma/cma-search.rest.schemal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYrC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/cjs/schemas/cma-transaction/cma-transaction-search.rest.schema.d.ts CHANGED Viewed

@@ -57,6 +57,34 @@ export declare const cmaTransactionSearchRestReqSchema: z.ZodIntersection<z.ZodO
                 endsWith: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>]>>;
         }, z.core.$strict>>, z.ZodString]>>;
+        accountNumber: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
+            equals: z.ZodOptional<z.ZodString>;
+            in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            lt: z.ZodOptional<z.ZodString>;
+            lte: z.ZodOptional<z.ZodString>;
+            gt: z.ZodOptional<z.ZodString>;
+            gte: z.ZodOptional<z.ZodString>;
+            contains: z.ZodOptional<z.ZodString>;
+            startsWith: z.ZodOptional<z.ZodString>;
+            endsWith: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodPrefault<z.ZodLazy<z.ZodEnum<{
+                readonly DEFAULT: "default";
+                readonly INSENSITIVE: "insensitive";
+            }>>>>;
+            not: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                lt: z.ZodOptional<z.ZodString>;
+                lte: z.ZodOptional<z.ZodString>;
+                gt: z.ZodOptional<z.ZodString>;
+                gte: z.ZodOptional<z.ZodString>;
+                contains: z.ZodOptional<z.ZodString>;
+                startsWith: z.ZodOptional<z.ZodString>;
+                endsWith: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>>;
+        }, z.core.$strict>>, z.ZodString]>>;
         id: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
             equals: z.ZodOptional<z.ZodString>;
             in: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -560,6 +588,34 @@ export declare const cmaTransactionSearchRestReqSchema: z.ZodIntersection<z.ZodO
                     endsWith: z.ZodOptional<z.ZodString>;
                 }, z.core.$strict>>]>>;
             }, z.core.$strict>>, z.ZodString]>>;
+            accountNumber: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                lt: z.ZodOptional<z.ZodString>;
+                lte: z.ZodOptional<z.ZodString>;
+                gt: z.ZodOptional<z.ZodString>;
+                gte: z.ZodOptional<z.ZodString>;
+                contains: z.ZodOptional<z.ZodString>;
+                startsWith: z.ZodOptional<z.ZodString>;
+                endsWith: z.ZodOptional<z.ZodString>;
+                mode: z.ZodOptional<z.ZodPrefault<z.ZodLazy<z.ZodEnum<{
+                    readonly DEFAULT: "default";
+                    readonly INSENSITIVE: "insensitive";
+                }>>>>;
+                not: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodObject<{
+                    equals: z.ZodOptional<z.ZodString>;
+                    in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    lt: z.ZodOptional<z.ZodString>;
+                    lte: z.ZodOptional<z.ZodString>;
+                    gt: z.ZodOptional<z.ZodString>;
+                    gte: z.ZodOptional<z.ZodString>;
+                    contains: z.ZodOptional<z.ZodString>;
+                    startsWith: z.ZodOptional<z.ZodString>;
+                    endsWith: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>]>>;
+            }, z.core.$strict>>, z.ZodString]>>;
             country: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
                 equals: z.ZodOptional<z.ZodString>;
                 in: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/cjs/schemas/cma-transaction/cma-transaction-search.rest.schema.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"cma-transaction-search.rest.schema.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/cma-transaction/cma-transaction-search.rest.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA8BR,CAAC;AAEvC,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iCAAiC,CAAC,CAAC"}
1	+ {"version":3,"file":"cma-transaction-search.rest.schema.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/cma-transaction/cma-transaction-search.rest.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA8BR,CAAC;AAEvC,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iCAAiC,CAAC,CAAC"}

package/dist/cjs/schemas/mta-transaction/mta-transaction-search.rest.schema.d.ts CHANGED Viewed

@@ -425,6 +425,34 @@ export declare const mtaTransactionSearchRestReqSchema: z.ZodIntersection<z.ZodO
                     endsWith: z.ZodOptional<z.ZodString>;
                 }, z.core.$strict>>]>>;
             }, z.core.$strict>>, z.ZodString]>>;
+            accountNumber: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                lt: z.ZodOptional<z.ZodString>;
+                lte: z.ZodOptional<z.ZodString>;
+                gt: z.ZodOptional<z.ZodString>;
+                gte: z.ZodOptional<z.ZodString>;
+                contains: z.ZodOptional<z.ZodString>;
+                startsWith: z.ZodOptional<z.ZodString>;
+                endsWith: z.ZodOptional<z.ZodString>;
+                mode: z.ZodOptional<z.ZodPrefault<z.ZodLazy<z.ZodEnum<{
+                    readonly DEFAULT: "default";
+                    readonly INSENSITIVE: "insensitive";
+                }>>>>;
+                not: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodObject<{
+                    equals: z.ZodOptional<z.ZodString>;
+                    in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    lt: z.ZodOptional<z.ZodString>;
+                    lte: z.ZodOptional<z.ZodString>;
+                    gt: z.ZodOptional<z.ZodString>;
+                    gte: z.ZodOptional<z.ZodString>;
+                    contains: z.ZodOptional<z.ZodString>;
+                    startsWith: z.ZodOptional<z.ZodString>;
+                    endsWith: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>]>>;
+            }, z.core.$strict>>, z.ZodString]>>;
             country: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
                 equals: z.ZodOptional<z.ZodString>;
                 in: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/cjs/schemas/mta-transaction/mta-transaction-search.rest.schema.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"mta-transaction-search.rest.schema.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/mta-transaction/mta-transaction-search.rest.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsBR,CAAC;AAEvC,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iCAAiC,CAAC,CAAC"}
1	+ {"version":3,"file":"mta-transaction-search.rest.schema.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/mta-transaction/mta-transaction-search.rest.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAsBR,CAAC;AAEvC,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE5F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iCAAiC,CAAC,CAAC"}

package/dist/cjs/schemas/property/property-search.rest.schema.d.ts CHANGED Viewed

@@ -648,6 +648,34 @@ export declare const propertySearchRestReqSchema: z.ZodObject<{
                 endsWith: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>]>>;
         }, z.core.$strict>>, z.ZodString]>>;
+        accountNumber: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
+            equals: z.ZodOptional<z.ZodString>;
+            in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            lt: z.ZodOptional<z.ZodString>;
+            lte: z.ZodOptional<z.ZodString>;
+            gt: z.ZodOptional<z.ZodString>;
+            gte: z.ZodOptional<z.ZodString>;
+            contains: z.ZodOptional<z.ZodString>;
+            startsWith: z.ZodOptional<z.ZodString>;
+            endsWith: z.ZodOptional<z.ZodString>;
+            mode: z.ZodOptional<z.ZodPrefault<z.ZodLazy<z.ZodEnum<{
+                readonly DEFAULT: "default";
+                readonly INSENSITIVE: "insensitive";
+            }>>>>;
+            not: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodObject<{
+                equals: z.ZodOptional<z.ZodString>;
+                in: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                notIn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                lt: z.ZodOptional<z.ZodString>;
+                lte: z.ZodOptional<z.ZodString>;
+                gt: z.ZodOptional<z.ZodString>;
+                gte: z.ZodOptional<z.ZodString>;
+                contains: z.ZodOptional<z.ZodString>;
+                startsWith: z.ZodOptional<z.ZodString>;
+                endsWith: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>]>>;
+        }, z.core.$strict>>, z.ZodString]>>;
         country: z.ZodOptional<z.ZodUnion<readonly [z.ZodLazy<z.ZodObject<{
             equals: z.ZodOptional<z.ZodString>;
             in: z.ZodOptional<z.ZodArray<z.ZodString>>;