@mikemo-coposit/am-accounting-shared 0.0.21 → 1.0.1-dev.2

package/dist/esm/constants/common/package-version.constant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-version.constant.d.ts","sourceRoot":"","sources":["../../../../packages/constants/common/package-version.constant.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,WAAW,CAAC"}
+{"version":3,"file":"package-version.constant.d.ts","sourceRoot":"","sources":["../../../../packages/constants/common/package-version.constant.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,gBAAgB,CAAC"}

package/dist/esm/index.mjs

@@ -118,6 +118,9 @@ const AccountingCommonSyncStatus = {
     SYNCED: 'synced',
     FAILED: 'failed'
 };
+const PACKAGE_VERSION = '1.0.1-dev.1';
+const DEFAULT_PAGE_SIZE = 500;
+const DEFAULT_PAGE = 1;
 var payment_method_constant_PaymentMethod = /*#__PURE__*/ function(PaymentMethod) {
     PaymentMethod["EFT"] = "EFT";
     return PaymentMethod;
@@ -1953,6 +1956,9 @@ const mtaTransactionRestResSchema = mtaTransactionRestResBaseSchema.extend({
     get reconciledTransactions () {
         return z.array(mtaReconciledTransactionRestResSchema).nullish();
     },
+    get payout () {
+        return payoutEntitySchema.nullish();
+    },
     isUnknown: z.boolean().optional(),
     isReceipt: z.boolean().optional(),
     isPayment: z.boolean().optional(),
@@ -2814,14 +2820,14 @@ const _global = (()=>{
 })();
 const isContextDefined = (context)=>!isUndefined(context) && context !== _global;
 function utils_merge() {
-    const { caseless } = isContextDefined(this) && this || {};
+    const { caseless, skipUndefined } = isContextDefined(this) && this || {};
     const result = {};
     const assignValue = (val, key)=>{
         const targetKey = caseless && findKey(result, key) || key;
         if (isPlainObject(result[targetKey]) && isPlainObject(val)) result[targetKey] = utils_merge(result[targetKey], val);
         else if (isPlainObject(val)) result[targetKey] = utils_merge({}, val);
         else if (isArray(val)) result[targetKey] = val.slice();
-        else result[targetKey] = val;
+        else if (!skipUndefined || !isUndefined(val)) result[targetKey] = val;
     };
     for(let i = 0, l = arguments.length; i < l; i++)arguments[i] && forEach(arguments[i], assignValue);
     return result;
@@ -3105,9 +3111,14 @@ AxiosError_AxiosError.from = (error, code, config, request, response, customProp
     utils.toFlatObject(error, axiosError, function(obj) {
         return obj !== Error.prototype;
     }, (prop)=>'isAxiosError' !== prop);
-    AxiosError_AxiosError.call(axiosError, error.message, code, config, request, response);
-    axiosError.cause = error;
-    axiosError.name = error.name;
+    const msg = error && error.message ? error.message : 'Error';
+    const errCode = null == code && error ? error.code : code;
+    AxiosError_AxiosError.call(axiosError, msg, errCode, config, request, response);
+    if (error && null == axiosError.cause) Object.defineProperty(axiosError, 'cause', {
+        value: error,
+        configurable: true
+    });
+    axiosError.name = error && error.name || 'Error';
     customProps && Object.assign(axiosError, customProps);
     return axiosError;
 };
@@ -3237,7 +3248,7 @@ AxiosURLSearchParams_prototype.toString = function(encoder) {
 };
 const AxiosURLSearchParams = AxiosURLSearchParams_AxiosURLSearchParams;
 function buildURL_encode(val) {
-    return encodeURIComponent(val).replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');
+    return encodeURIComponent(val).replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+');
 }
 function buildURL(url, params, options) {
     if (!params) return url;
@@ -3432,7 +3443,7 @@ const defaults = {
                 const silentJSONParsing = transitional && transitional.silentJSONParsing;
                 const strictJSONParsing = !silentJSONParsing && JSONRequested;
                 try {
-                    return JSON.parse(data);
+                    return JSON.parse(data, this.parseReviver);
                 } catch (e) {
                     if (strictJSONParsing) {
                         if ('SyntaxError' === e.name) throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
@@ -3964,15 +3975,17 @@ const resolveConfig = (config)=>{
     newConfig.headers = headers = AxiosHeaders.from(headers);
     newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
     if (auth) headers.set('Authorization', 'Basic ' + btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : '')));
-    let contentType;
     if (utils.isFormData(data)) {
         if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) headers.setContentType(void 0);
-        else if (false !== (contentType = headers.getContentType())) {
-            const [type, ...tokens] = contentType ? contentType.split(';').map((token)=>token.trim()).filter(Boolean) : [];
-            headers.setContentType([
-                type || 'multipart/form-data',
-                ...tokens
-            ].join('; '));
+        else if (utils.isFunction(data.getHeaders)) {
+            const formHeaders = data.getHeaders();
+            const allowedHeaders = [
+                'content-type',
+                'content-length'
+            ];
+            Object.entries(formHeaders).forEach(([key, val])=>{
+                if (allowedHeaders.includes(key.toLowerCase())) headers.set(key, val);
+            });
         }
     }
     if (platform.hasStandardBrowserEnv) {
@@ -4035,8 +4048,11 @@ const xhr = isXHRAdapterSupported && function(config) {
             reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));
             request = null;
         };
-        request.onerror = function() {
-            reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));
+        request.onerror = function(event) {
+            const msg = event && event.message ? event.message : 'Network Error';
+            const err = new AxiosError(msg, AxiosError.ERR_NETWORK, config, request);
+            err.event = event || null;
+            reject(err);
             request = null;
         };
         request.ontimeout = function() {
@@ -4175,9 +4191,13 @@ const trackStream = (stream, chunkSize, onProgress, onFinish)=>{
         highWaterMark: 2
     });
 };
-const isFetchSupported = 'function' == typeof fetch && 'function' == typeof Request && 'function' == typeof Response;
-const isReadableStreamSupported = isFetchSupported && 'function' == typeof ReadableStream;
-const encodeText = isFetchSupported && ('function' == typeof TextEncoder ? ((encoder)=>(str)=>encoder.encode(str))(new TextEncoder()) : async (str)=>new Uint8Array(await new Response(str).arrayBuffer()));
+const DEFAULT_CHUNK_SIZE = 65536;
+const { isFunction: fetch_isFunction } = utils;
+const globalFetchAPI = (({ Request, Response })=>({
+        Request,
+        Response
+    }))(utils.global);
+const { ReadableStream: fetch_ReadableStream, TextEncoder } = utils.global;
 const test = (fn, ...args)=>{
     try {
         return !!fn(...args);
@@ -4185,134 +4205,170 @@ const test = (fn, ...args)=>{
         return false;
     }
 };
-const supportsRequestStream = isReadableStreamSupported && test(()=>{
-    let duplexAccessed = false;
-    const hasContentType = new Request(platform.origin, {
-        body: new ReadableStream(),
-        method: 'POST',
-        get duplex () {
-            duplexAccessed = true;
-            return 'half';
-        }
-    }).headers.has('Content-Type');
-    return duplexAccessed && !hasContentType;
-});
-const DEFAULT_CHUNK_SIZE = 65536;
-const supportsResponseStream = isReadableStreamSupported && test(()=>utils.isReadableStream(new Response('').body));
-const resolvers = {
-    stream: supportsResponseStream && ((res)=>res.body)
-};
-isFetchSupported && ((res)=>{
-    [
-        'text',
-        'arrayBuffer',
-        'blob',
-        'formData',
-        'stream'
-    ].forEach((type)=>{
-        resolvers[type] || (resolvers[type] = utils.isFunction(res[type]) ? (res)=>res[type]() : (_, config)=>{
-            throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
-        });
-    });
-})(new Response);
-const getBodyLength = async (body)=>{
-    if (null == body) return 0;
-    if (utils.isBlob(body)) return body.size;
-    if (utils.isSpecCompliantForm(body)) {
-        const _request = new Request(platform.origin, {
+const factory = (env)=>{
+    env = utils.merge.call({
+        skipUndefined: true
+    }, globalFetchAPI, env);
+    const { fetch: envFetch, Request, Response } = env;
+    const isFetchSupported = envFetch ? fetch_isFunction(envFetch) : 'function' == typeof fetch;
+    const isRequestSupported = fetch_isFunction(Request);
+    const isResponseSupported = fetch_isFunction(Response);
+    if (!isFetchSupported) return false;
+    const isReadableStreamSupported = isFetchSupported && fetch_isFunction(fetch_ReadableStream);
+    const encodeText = isFetchSupported && ('function' == typeof TextEncoder ? ((encoder)=>(str)=>encoder.encode(str))(new TextEncoder()) : async (str)=>new Uint8Array(await new Request(str).arrayBuffer()));
+    const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(()=>{
+        let duplexAccessed = false;
+        const hasContentType = new Request(platform.origin, {
+            body: new fetch_ReadableStream(),
             method: 'POST',
-            body
-        });
-        return (await _request.arrayBuffer()).byteLength;
-    }
-    if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) return body.byteLength;
-    if (utils.isURLSearchParams(body)) body += '';
-    if (utils.isString(body)) return (await encodeText(body)).byteLength;
-};
-const resolveBodyLength = async (headers, body)=>{
-    const length = utils.toFiniteNumber(headers.getContentLength());
-    return null == length ? getBodyLength(body) : length;
-};
-const adapters_fetch = isFetchSupported && (async (config)=>{
-    let { url, method, data, signal, cancelToken, timeout, onDownloadProgress, onUploadProgress, responseType, headers, withCredentials = 'same-origin', fetchOptions } = resolveConfig(config);
-    responseType = responseType ? (responseType + '').toLowerCase() : 'text';
-    let composedSignal = helpers_composeSignals([
-        signal,
-        cancelToken && cancelToken.toAbortSignal()
-    ], timeout);
-    let request;
-    const unsubscribe = composedSignal && composedSignal.unsubscribe && (()=>{
-        composedSignal.unsubscribe();
+            get duplex () {
+                duplexAccessed = true;
+                return 'half';
+            }
+        }).headers.has('Content-Type');
+        return duplexAccessed && !hasContentType;
     });
-    let requestContentLength;
-    try {
-        if (onUploadProgress && supportsRequestStream && 'get' !== method && 'head' !== method && 0 !== (requestContentLength = await resolveBodyLength(headers, data))) {
-            let _request = new Request(url, {
+    const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(()=>utils.isReadableStream(new Response('').body));
+    const resolvers = {
+        stream: supportsResponseStream && ((res)=>res.body)
+    };
+    isFetchSupported && (()=>{
+        [
+            'text',
+            'arrayBuffer',
+            'blob',
+            'formData',
+            'stream'
+        ].forEach((type)=>{
+            resolvers[type] || (resolvers[type] = (res, config)=>{
+                let method = res && res[type];
+                if (method) return method.call(res);
+                throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
+            });
+        });
+    })();
+    const getBodyLength = async (body)=>{
+        if (null == body) return 0;
+        if (utils.isBlob(body)) return body.size;
+        if (utils.isSpecCompliantForm(body)) {
+            const _request = new Request(platform.origin, {
                 method: 'POST',
-                body: data,
-                duplex: "half"
+                body
             });
-            let contentTypeHeader;
-            if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) headers.setContentType(contentTypeHeader);
-            if (_request.body) {
-                const [onProgress, flush] = progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress)));
-                data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
-            }
+            return (await _request.arrayBuffer()).byteLength;
         }
-        if (!utils.isString(withCredentials)) withCredentials = withCredentials ? 'include' : 'omit';
-        const isCredentialsSupported = "credentials" in Request.prototype;
-        request = new Request(url, {
-            ...fetchOptions,
-            signal: composedSignal,
-            method: method.toUpperCase(),
-            headers: headers.normalize().toJSON(),
-            body: data,
-            duplex: "half",
-            credentials: isCredentialsSupported ? withCredentials : void 0
+        if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) return body.byteLength;
+        if (utils.isURLSearchParams(body)) body += '';
+        if (utils.isString(body)) return (await encodeText(body)).byteLength;
+    };
+    const resolveBodyLength = async (headers, body)=>{
+        const length = utils.toFiniteNumber(headers.getContentLength());
+        return null == length ? getBodyLength(body) : length;
+    };
+    return async (config)=>{
+        let { url, method, data, signal, cancelToken, timeout, onDownloadProgress, onUploadProgress, responseType, headers, withCredentials = 'same-origin', fetchOptions } = resolveConfig(config);
+        let _fetch = envFetch || fetch;
+        responseType = responseType ? (responseType + '').toLowerCase() : 'text';
+        let composedSignal = helpers_composeSignals([
+            signal,
+            cancelToken && cancelToken.toAbortSignal()
+        ], timeout);
+        let request = null;
+        const unsubscribe = composedSignal && composedSignal.unsubscribe && (()=>{
+            composedSignal.unsubscribe();
         });
-        let response = await fetch(request, fetchOptions);
-        const isStreamResponse = supportsResponseStream && ('stream' === responseType || 'response' === responseType);
-        if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
-            const options = {};
-            [
-                'status',
-                'statusText',
-                'headers'
-            ].forEach((prop)=>{
-                options[prop] = response[prop];
+        let requestContentLength;
+        try {
+            if (onUploadProgress && supportsRequestStream && 'get' !== method && 'head' !== method && 0 !== (requestContentLength = await resolveBodyLength(headers, data))) {
+                let _request = new Request(url, {
+                    method: 'POST',
+                    body: data,
+                    duplex: "half"
+                });
+                let contentTypeHeader;
+                if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) headers.setContentType(contentTypeHeader);
+                if (_request.body) {
+                    const [onProgress, flush] = progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress)));
+                    data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+                }
+            }
+            if (!utils.isString(withCredentials)) withCredentials = withCredentials ? 'include' : 'omit';
+            const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
+            const resolvedOptions = {
+                ...fetchOptions,
+                signal: composedSignal,
+                method: method.toUpperCase(),
+                headers: headers.normalize().toJSON(),
+                body: data,
+                duplex: "half",
+                credentials: isCredentialsSupported ? withCredentials : void 0
+            };
+            request = isRequestSupported && new Request(url, resolvedOptions);
+            let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
+            const isStreamResponse = supportsResponseStream && ('stream' === responseType || 'response' === responseType);
+            if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
+                const options = {};
+                [
+                    'status',
+                    'statusText',
+                    'headers'
+                ].forEach((prop)=>{
+                    options[prop] = response[prop];
+                });
+                const responseContentLength = utils.toFiniteNumber(response.headers.get('content-length'));
+                const [onProgress, flush] = onDownloadProgress && progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true)) || [];
+                response = new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, ()=>{
+                    flush && flush();
+                    unsubscribe && unsubscribe();
+                }), options);
+            }
+            responseType = responseType || 'text';
+            let responseData = await resolvers[utils.findKey(resolvers, responseType) || 'text'](response, config);
+            !isStreamResponse && unsubscribe && unsubscribe();
+            return await new Promise((resolve, reject)=>{
+                settle(resolve, reject, {
+                    data: responseData,
+                    headers: AxiosHeaders.from(response.headers),
+                    status: response.status,
+                    statusText: response.statusText,
+                    config,
+                    request
+                });
             });
-            const responseContentLength = utils.toFiniteNumber(response.headers.get('content-length'));
-            const [onProgress, flush] = onDownloadProgress && progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true)) || [];
-            response = new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, ()=>{
-                flush && flush();
-                unsubscribe && unsubscribe();
-            }), options);
-        }
-        responseType = responseType || 'text';
-        let responseData = await resolvers[utils.findKey(resolvers, responseType) || 'text'](response, config);
-        !isStreamResponse && unsubscribe && unsubscribe();
-        return await new Promise((resolve, reject)=>{
-            settle(resolve, reject, {
-                data: responseData,
-                headers: AxiosHeaders.from(response.headers),
-                status: response.status,
-                statusText: response.statusText,
-                config,
-                request
+        } catch (err) {
+            unsubscribe && unsubscribe();
+            if (err && 'TypeError' === err.name && /Load failed|fetch/i.test(err.message)) throw Object.assign(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request), {
+                cause: err.cause || err
             });
-        });
-    } catch (err) {
-        unsubscribe && unsubscribe();
-        if (err && 'TypeError' === err.name && /Load failed|fetch/i.test(err.message)) throw Object.assign(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request), {
-            cause: err.cause || err
-        });
-        throw AxiosError.from(err, err && err.code, config, request);
+            throw AxiosError.from(err, err && err.code, config, request);
+        }
+    };
+};
+const seedCache = new Map();
+const getFetch = (config)=>{
+    let env = config ? config.env : {};
+    const { fetch: fetch1, Request, Response } = env;
+    const seeds = [
+        Request,
+        Response,
+        fetch1
+    ];
+    let len = seeds.length, i = len, seed, target, map = seedCache;
+    while(i--){
+        seed = seeds[i];
+        target = map.get(seed);
+        void 0 === target && map.set(seed, target = i ? new Map() : factory(env));
+        map = target;
     }
-});
+    return target;
+};
+getFetch();
 const knownAdapters = {
     http: helpers_null,
     xhr: xhr,
-    fetch: adapters_fetch
+    fetch: {
+        get: getFetch
+    }
 };
 utils.forEach(knownAdapters, (fn, value)=>{
     if (fn) {
@@ -4329,7 +4385,7 @@ utils.forEach(knownAdapters, (fn, value)=>{
 const renderReason = (reason)=>`- ${reason}`;
 const isResolvedHandle = (adapter)=>utils.isFunction(adapter) || null === adapter || false === adapter;
 const adapters_adapters = {
-    getAdapter: (adapters)=>{
+    getAdapter: (adapters, config)=>{
         adapters = utils.isArray(adapters) ? adapters : [
             adapters
         ];
@@ -4345,7 +4401,7 @@ const adapters_adapters = {
                 adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
                 if (void 0 === adapter) throw new AxiosError(`Unknown adapter '${id}'`);
             }
-            if (adapter) break;
+            if (adapter && (utils.isFunction(adapter) || (adapter = adapter.get(config)))) break;
             rejectedReasons[id || '#' + i] = adapter;
         }
         if (!adapter) {
@@ -4370,7 +4426,7 @@ function dispatchRequest(config) {
         'put',
         'patch'
     ].indexOf(config.method)) config.headers.setContentType('application/x-www-form-urlencoded', false);
-    const adapter = adapters_adapters.getAdapter(config.adapter || lib_defaults.adapter);
+    const adapter = adapters_adapters.getAdapter(config.adapter || lib_defaults.adapter, config);
     return adapter(config).then(function(response) {
         throwIfCancellationRequested(config);
         response.data = transformData.call(config, config.transformResponse, response);
@@ -4387,6 +4443,7 @@ function dispatchRequest(config) {
         return Promise.reject(reason);
     });
 }
+const VERSION = "1.12.2";
 const validators = {};
 [
     'object',
@@ -4403,7 +4460,7 @@ const validators = {};
 const deprecatedWarnings = {};
 validators.transitional = function(validator, version, message) {
     function formatMessage(opt, desc) {
-        return "[Axios v1.11.0] Transitional option '" + opt + '\'' + desc + (message ? '. ' + message : '');
+        return '[Axios v' + VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
     }
     return (value, opt, opts)=>{
         if (false === validator) throw new AxiosError(formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')), AxiosError.ERR_DEPRECATED);
@@ -4534,7 +4591,6 @@ class Axios_Axios {
         }
         len = requestInterceptorChain.length;
         let newConfig = config;
-        i = 0;
         while(i < len){
             const onFulfilled = requestInterceptorChain[i++];
             const onRejected = requestInterceptorChain[i++];
@@ -4759,7 +4815,7 @@ axios.Axios = Axios;
 axios.CanceledError = cancel_CanceledError;
 axios.CancelToken = CancelToken;
 axios.isCancel = isCancel;
-axios.VERSION = "1.11.0";
+axios.VERSION = VERSION;
 axios.toFormData = helpers_toFormData;
 axios.AxiosError = AxiosError;
 axios.Cancel = axios.CanceledError;
@@ -4913,7 +4969,4 @@ const getPropertyName = (property, options)=>{
     names = names.filter(Boolean);
     return names.length > 0 ? names.join(separator) : 'Nill';
 };
-var __webpack_exports__DEFAULT_PAGE = 1;
-var __webpack_exports__DEFAULT_PAGE_SIZE = 500;
-var __webpack_exports__PACKAGE_VERSION = "0.0.20";
-export { ASSIGN_UNKNOWN_TO_CUSTOMER, account_period_constant_AccountPeriodStatus as AccountPeriodStatus, account_type_constant_AccountType as AccountType, common_status_constant_AccountingCommonStatus as AccountingCommonStatus, AccountingCommonSyncStatus, AmmoZeptoBankAccounts, AmmoZeptoClient, CmaPayoutTransactionType, CmaReceiptTransactionType, CmaStatus, cma_input_type_constant_CmaTransactionCreateType as CmaTransactionCreateType, CmaTransactionCreateTypeToDisplayText, cma_input_type_constant_CmaTransactionInputType as CmaTransactionInputType, CmaTransactionInputTypeToDisplayText, cma_payment_method_constant_CmaTransactionPaymentMethod as CmaTransactionPaymentMethod, CmaTransactionStatus, CmaTransactionStatusToDisplayTextMapper, CmaTransactionType, CmaTransactionTypeToDisplayTextMapper, DATE_FORMATS, DEFAULT_DATE_FORMAT, DEFAULT_DATE_FORMAT_WITH_TIME, DEFAULT_DATE_TIME_ZONE, DEFAULT_PAYOUT_SOURCE_BANK_REF, DEFAULT_PAYOUT_SOURCE_DESCRIPTION, DEFAULT_PAYOUT_TARGET_BANK_REF, DEFAULT_PAYOUT_TARGET_DESCRIPTION, InputJsonValueSchema, JsonNullableFilterSchema, MenuStatus, MenuType, MtaCustomerTransactionType, MtaPayoutTransactionType, MtaReceiptTransactionType, mta_MtaStatus as MtaStatus, MtaTransactionExtendedStatus, MtaTransactionExtendedStatusToDisplayTextMapper, mta_input_type_constant_MtaTransactionInputType as MtaTransactionInputType, MtaTransactionInputTypeToDisplayText, mta_payment_method_constant_MtaTransactionPaymentMethod as MtaTransactionPaymentMethod, MtaTransactionStatus, MtaTransactionStatusToDisplayTextMapper, MtaTransactionType, MtaTransactionTypeToDisplayTextMapper, MtaUnknownTransactionType, payment_method_constant_PaymentMethod as PaymentMethod, PayoutBankFileStatus, payout_constant_PayoutSourceAccountType as PayoutSourceAccountType, PayoutStatus, payout_constant_PayoutTargetAccountType as PayoutTargetAccountType, PayoutType, ProjectApplyStatusRestRes, ProjectMtaAllocationStatus, PropertyInitialDepositStatus, PropertyInitialDepositStatusToDisplayTextMapper, property_status_constant_PropertyRestResStatus as PropertyRestResStatus, PropertyStage, PropertyStatusToDisplayTextMapper, QueryMode, reconcile_transaction_action_constant_ReconcileTransactionAction as ReconcileTransactionAction, reconciliation_constant_ReconciliationStatus as ReconciliationStatus, report_data_range_type_constant_ReportDataRangeType as ReportDataRangeType, report_group_type_constant_ReportGroupType as ReportGroupType, sort_order_constant_SortOrder as SortOrder, StringFilterBaseSchema, TRANSACTION_CANCEL, accountBsbFormattedSchema, accountBsbMaskedSchema, accountBsbValidationSchema, accountNumberMaskedSchema, accountNumberValidationSchema, allocateMtaToProjectRestReqSchema, approveMtaAllocationRestReqSchema, assignUnknownReceiptToPropertyRestReqSchema, balanceRestResSchema, bankCodeSchema, bankReconciliationSummaryRestReqSchema, bigIntFilterSchema, bigIntNullableFilterSchema, bigIntNullableObjectFilterSchema, bigIntObjectFilterSchema, bigIntSimpleFilterSchema, boolFilterBaseSchema, boolFilterSchema, cancelCmaTransactionRestReqSchema, cancelMtaTransactionRestReqSchema, cancelPayoutPaymentRestReqSchema, cancelPayoutRestReqSchema, centsToDollarsSchema, cmaAccountPeriodCloseRestReqSchema, cmaAccountPeriodClosingSummaryRestReqSchema, cmaAccountPeriodClosingSummaryRestResSchema, cmaAccountPeriodEntitySchema, cmaAccountPeriodRestResBaseSchema, cmaAccountPeriodRestResSchema, cmaClosedAccountPeriodRestResSchema, cmaEntitySchema, cmaReconciledTransactionEntitySchema, cmaReconciledTransactionRestResSchema, cmaReconciliationEntitySchema, cmaReconciliationRestResSchema, cmaRestResBaseSchema, cmaRestResSchema, cmaSearchRestReqSchema, cmaSettlementPayoutRestResSchema, cmaTransactionEntitySchema, cmaTransactionRestResBaseSchema, cmaTransactionRestResSchema, cmaTransactionSearchRestReqSchema, commonPayoutSourceDetailEntitySchema, commonPayoutTargetDetailEntitySchema, commonReportRestReqSchema, commonReportWithCmaSelectionRestReqSchema, commonUpdatePayoutRestReqSchema, commonUpdatePayoutTargetDetailRestReqSchema, confirmPayoutBankFileProcessedRestReqSchema, createCmaReconciliationRestReqSchema, createCmaRestReqSchema, createCmaTransactionRestReqSchema, createMenuRestReqSchema, createMtaReconciliationRestReqSchema, createMtaRestReqSchema, createMtaToCmaPayoutRestReqSchema, createMtaTransactionRestReqSchema, createSettlementPayoutRestReqSchema, createSettlementPayoutSourceAccountSchema, createSettlementPayoutTargetAccountSchema, createUnknownPayoutRestReqSchema, customerEntitySchema, customerLedgerRestReqSchema, customerSyncFromAmmozeGrpcReqSchema, dateTimeFilterBaseSchema, dateTimeFilterSchema, developerEntitySchema, displayBankAccount, dollarsToCentsSchema, extendDayjs, formatBankBsb, formatCurrency, fromCentsToDollars, fromDollarsToCents, generateMtaPaymentMethodAccountConfigForZepto, generateMtaPaymentMethodFloatAccountConfigForZepto, getPropertyName, getTransactionAmountStr, getTransactionNumber, getTransactionStatus, intFilterSchema, intNullableFilterSchema, intNullableObjectFilterSchema, intObjectFilterSchema, intSimpleFilterSchema, isInterestTransaction, isPaymentTransaction, isReceiptTransaction, isTransactionAssignable, isTransactionCancelable, isUnknownReceiptAssignedToProperty, isUnknownReceiptPaidOut, isUnknownTransaction, markCmaTransactionAsClearedRestReqSchema, maskBankAccount, maskBankAccountNumber, maskBankBsb, maskString, menuRestResSchema, menuSchema, mtaAccountPeriodCloseRestReqSchema, mtaAccountPeriodClosingSummaryRestReqSchema, mtaAccountPeriodClosingSummaryRestResSchema, mtaAccountPeriodEntitySchema, mtaAccountPeriodRestResSchema, mtaClosedAccountPeriodRestResSchema, mtaEntitySchema, mtaListItemRestResSchema, mtaPaymentMethodAccountConfigSchema, mtaPaymentMethodEntitySchema, mtaPaymentMethodFloatAccountConfigSchema, mtaPaymentMethodRestResSchema, mtaReconciledTransactionEntitySchema, mtaReconciledTransactionRestResSchema, mtaReconciliationEntitySchema, mtaReconciliationRestResSchema, mtaRestResBaseSchema, mtaRestResSchema, mtaSettlementPayoutRestResSchema, mtaToCmaPayoutPaymentEntitySchema, mtaToCmaPayoutPaymentRestSchema, mtaToCmaPayoutProvisionDataEntitySchema, mtaToCmaPayoutProvisionDataRestSchema, mtaToCmaPayoutRestResSchema, mtaToCmaPayoutSourceDetailEntitySchema, mtaToCmaPayoutSourceDetailRestSchema, mtaToCmaPayoutTargetDetailEntitySchema, mtaToCmaPayoutTargetDetailRestSchema, mtaTransactionEntitySchema, mtaTransactionNestedSchema, mtaTransactionRestResBaseSchema, mtaTransactionRestResSchema, mtaTransactionSearchRestReqSchema, mtaTransactionStatusSummaryRestResSchema, paginatedResSchema, paginationReqSchema, parseToDate, parseToDayjs, paymentListReportRestReqSchema, paymentProviderEntitySchema, payoutBankFileDownloadHistoryEntitySchema, payoutBankFileEntitySchema, payoutBankFileRestResSchema, payoutEntitySchema, payoutProvisionDataEntitySchema, payoutRestResBaseSchema, payoutRestResSchema, payoutSearchRestReqSchema, payoutStatusSummaryRestResSchema, payoutTransactionEntitySchema, payoutTransactionRestResSchema, payoutTransactionSearchRestReqSchema, payoutUpdateRestReqSchema, projectEntitySchema, projectLedgerRestReqSchema, projectMtaAllocationEntitySchema, projectMtaAllocationRestResSchema, projectNestedEntitySchema, projectRestResSchema, projectSearchRestReqSchema, propertyAccountsBalanceRestResSchema, propertyEntitySchema, propertyNestedEntitySchema, propertyRestResBaseSchema, propertyRestResSchema, propertySearchRestReqSchema, propertySyncFromAmmozeGrpcReqSchema, queryModeSchema, receiptListReportRestReqSchema, reconcileCmaTransactionRestReqSchema, reconcileMtaTransactionRestReqSchema, reconciledItemsListReportRestReqSchema, safeParseDateFromStr, settlementPayoutPaymentEntitySchema, settlementPayoutProvisionDataEntitySchema, settlementPayoutRestResSchema, settlementPayoutSourceDetailEntitySchema, settlementPayoutTargetDetailEntitySchema, simpleStringFilterSchema, sortReqSchema, stateCodeSchema, statusFilterSchema, statusNullableFilterSchema, stringFilterSchema, stringNullableFilterSchema, stringToBoolSchema, stringToDateSchema, stringToEndOfDaySchema, stringToStartOfDaySchema, trustTrialBalanceReportRestReqSchema, unknownPayoutPaymentEntitySchema, unknownPayoutProvisionDataEntitySchema, unknownPayoutRestResSchema, unknownPayoutSourceDetailEntitySchema, unknownPayoutTargetDetailEntitySchema, unknownReceiptLedgerRestReqSchema, unreconciledItemsListReportRestReqSchema, updateCmaOpenReconciliationCurrentBankStatementBalanceRestReqSchema, updateCmaSettlementPayoutRestReqSchema, updateMenuRestReqSchema, updateMtaRestReqSchema, updateMtaSettlementPayoutRestReqSchema, updateMtaToCmaPayoutRestReqSchema, updateMtaTransactionRestReqSchema, updateOpenReconciliationCurrentBankStatementBalanceRestReqSchema, updateSettlementPayoutRestReqSchema, updateUnknownPayoutRestReqSchema, updateUnknownPayoutTargetDetailRestReqSchema, userEntitySchema, userRestResSchema, validateGetPropertyNameFormat, __webpack_exports__DEFAULT_PAGE as DEFAULT_PAGE, __webpack_exports__DEFAULT_PAGE_SIZE as DEFAULT_PAGE_SIZE, __webpack_exports__PACKAGE_VERSION as PACKAGE_VERSION };
+export { ASSIGN_UNKNOWN_TO_CUSTOMER, account_period_constant_AccountPeriodStatus as AccountPeriodStatus, account_type_constant_AccountType as AccountType, common_status_constant_AccountingCommonStatus as AccountingCommonStatus, AccountingCommonSyncStatus, AmmoZeptoBankAccounts, AmmoZeptoClient, CmaPayoutTransactionType, CmaReceiptTransactionType, CmaStatus, cma_input_type_constant_CmaTransactionCreateType as CmaTransactionCreateType, CmaTransactionCreateTypeToDisplayText, cma_input_type_constant_CmaTransactionInputType as CmaTransactionInputType, CmaTransactionInputTypeToDisplayText, cma_payment_method_constant_CmaTransactionPaymentMethod as CmaTransactionPaymentMethod, CmaTransactionStatus, CmaTransactionStatusToDisplayTextMapper, CmaTransactionType, CmaTransactionTypeToDisplayTextMapper, DATE_FORMATS, DEFAULT_DATE_FORMAT, DEFAULT_DATE_FORMAT_WITH_TIME, DEFAULT_DATE_TIME_ZONE, DEFAULT_PAGE, DEFAULT_PAGE_SIZE, DEFAULT_PAYOUT_SOURCE_BANK_REF, DEFAULT_PAYOUT_SOURCE_DESCRIPTION, DEFAULT_PAYOUT_TARGET_BANK_REF, DEFAULT_PAYOUT_TARGET_DESCRIPTION, InputJsonValueSchema, JsonNullableFilterSchema, MenuStatus, MenuType, MtaCustomerTransactionType, MtaPayoutTransactionType, MtaReceiptTransactionType, mta_MtaStatus as MtaStatus, MtaTransactionExtendedStatus, MtaTransactionExtendedStatusToDisplayTextMapper, mta_input_type_constant_MtaTransactionInputType as MtaTransactionInputType, MtaTransactionInputTypeToDisplayText, mta_payment_method_constant_MtaTransactionPaymentMethod as MtaTransactionPaymentMethod, MtaTransactionStatus, MtaTransactionStatusToDisplayTextMapper, MtaTransactionType, MtaTransactionTypeToDisplayTextMapper, MtaUnknownTransactionType, PACKAGE_VERSION, payment_method_constant_PaymentMethod as PaymentMethod, PayoutBankFileStatus, payout_constant_PayoutSourceAccountType as PayoutSourceAccountType, PayoutStatus, payout_constant_PayoutTargetAccountType as PayoutTargetAccountType, PayoutType, ProjectApplyStatusRestRes, ProjectMtaAllocationStatus, PropertyInitialDepositStatus, PropertyInitialDepositStatusToDisplayTextMapper, property_status_constant_PropertyRestResStatus as PropertyRestResStatus, PropertyStage, PropertyStatusToDisplayTextMapper, QueryMode, reconcile_transaction_action_constant_ReconcileTransactionAction as ReconcileTransactionAction, reconciliation_constant_ReconciliationStatus as ReconciliationStatus, report_data_range_type_constant_ReportDataRangeType as ReportDataRangeType, report_group_type_constant_ReportGroupType as ReportGroupType, sort_order_constant_SortOrder as SortOrder, StringFilterBaseSchema, TRANSACTION_CANCEL, accountBsbFormattedSchema, accountBsbMaskedSchema, accountBsbValidationSchema, accountNumberMaskedSchema, accountNumberValidationSchema, allocateMtaToProjectRestReqSchema, approveMtaAllocationRestReqSchema, assignUnknownReceiptToPropertyRestReqSchema, balanceRestResSchema, bankCodeSchema, bankReconciliationSummaryRestReqSchema, bigIntFilterSchema, bigIntNullableFilterSchema, bigIntNullableObjectFilterSchema, bigIntObjectFilterSchema, bigIntSimpleFilterSchema, boolFilterBaseSchema, boolFilterSchema, cancelCmaTransactionRestReqSchema, cancelMtaTransactionRestReqSchema, cancelPayoutPaymentRestReqSchema, cancelPayoutRestReqSchema, centsToDollarsSchema, cmaAccountPeriodCloseRestReqSchema, cmaAccountPeriodClosingSummaryRestReqSchema, cmaAccountPeriodClosingSummaryRestResSchema, cmaAccountPeriodEntitySchema, cmaAccountPeriodRestResBaseSchema, cmaAccountPeriodRestResSchema, cmaClosedAccountPeriodRestResSchema, cmaEntitySchema, cmaReconciledTransactionEntitySchema, cmaReconciledTransactionRestResSchema, cmaReconciliationEntitySchema, cmaReconciliationRestResSchema, cmaRestResBaseSchema, cmaRestResSchema, cmaSearchRestReqSchema, cmaSettlementPayoutRestResSchema, cmaTransactionEntitySchema, cmaTransactionRestResBaseSchema, cmaTransactionRestResSchema, cmaTransactionSearchRestReqSchema, commonPayoutSourceDetailEntitySchema, commonPayoutTargetDetailEntitySchema, commonReportRestReqSchema, commonReportWithCmaSelectionRestReqSchema, commonUpdatePayoutRestReqSchema, commonUpdatePayoutTargetDetailRestReqSchema, confirmPayoutBankFileProcessedRestReqSchema, createCmaReconciliationRestReqSchema, createCmaRestReqSchema, createCmaTransactionRestReqSchema, createMenuRestReqSchema, createMtaReconciliationRestReqSchema, createMtaRestReqSchema, createMtaToCmaPayoutRestReqSchema, createMtaTransactionRestReqSchema, createSettlementPayoutRestReqSchema, createSettlementPayoutSourceAccountSchema, createSettlementPayoutTargetAccountSchema, createUnknownPayoutRestReqSchema, customerEntitySchema, customerLedgerRestReqSchema, customerSyncFromAmmozeGrpcReqSchema, dateTimeFilterBaseSchema, dateTimeFilterSchema, developerEntitySchema, displayBankAccount, dollarsToCentsSchema, extendDayjs, formatBankBsb, formatCurrency, fromCentsToDollars, fromDollarsToCents, generateMtaPaymentMethodAccountConfigForZepto, generateMtaPaymentMethodFloatAccountConfigForZepto, getPropertyName, getTransactionAmountStr, getTransactionNumber, getTransactionStatus, intFilterSchema, intNullableFilterSchema, intNullableObjectFilterSchema, intObjectFilterSchema, intSimpleFilterSchema, isInterestTransaction, isPaymentTransaction, isReceiptTransaction, isTransactionAssignable, isTransactionCancelable, isUnknownReceiptAssignedToProperty, isUnknownReceiptPaidOut, isUnknownTransaction, markCmaTransactionAsClearedRestReqSchema, maskBankAccount, maskBankAccountNumber, maskBankBsb, maskString, menuRestResSchema, menuSchema, mtaAccountPeriodCloseRestReqSchema, mtaAccountPeriodClosingSummaryRestReqSchema, mtaAccountPeriodClosingSummaryRestResSchema, mtaAccountPeriodEntitySchema, mtaAccountPeriodRestResSchema, mtaClosedAccountPeriodRestResSchema, mtaEntitySchema, mtaListItemRestResSchema, mtaPaymentMethodAccountConfigSchema, mtaPaymentMethodEntitySchema, mtaPaymentMethodFloatAccountConfigSchema, mtaPaymentMethodRestResSchema, mtaReconciledTransactionEntitySchema, mtaReconciledTransactionRestResSchema, mtaReconciliationEntitySchema, mtaReconciliationRestResSchema, mtaRestResBaseSchema, mtaRestResSchema, mtaSettlementPayoutRestResSchema, mtaToCmaPayoutPaymentEntitySchema, mtaToCmaPayoutPaymentRestSchema, mtaToCmaPayoutProvisionDataEntitySchema, mtaToCmaPayoutProvisionDataRestSchema, mtaToCmaPayoutRestResSchema, mtaToCmaPayoutSourceDetailEntitySchema, mtaToCmaPayoutSourceDetailRestSchema, mtaToCmaPayoutTargetDetailEntitySchema, mtaToCmaPayoutTargetDetailRestSchema, mtaTransactionEntitySchema, mtaTransactionNestedSchema, mtaTransactionRestResBaseSchema, mtaTransactionRestResSchema, mtaTransactionSearchRestReqSchema, mtaTransactionStatusSummaryRestResSchema, paginatedResSchema, paginationReqSchema, parseToDate, parseToDayjs, paymentListReportRestReqSchema, paymentProviderEntitySchema, payoutBankFileDownloadHistoryEntitySchema, payoutBankFileEntitySchema, payoutBankFileRestResSchema, payoutEntitySchema, payoutProvisionDataEntitySchema, payoutRestResBaseSchema, payoutRestResSchema, payoutSearchRestReqSchema, payoutStatusSummaryRestResSchema, payoutTransactionEntitySchema, payoutTransactionRestResSchema, payoutTransactionSearchRestReqSchema, payoutUpdateRestReqSchema, projectEntitySchema, projectLedgerRestReqSchema, projectMtaAllocationEntitySchema, projectMtaAllocationRestResSchema, projectNestedEntitySchema, projectRestResSchema, projectSearchRestReqSchema, propertyAccountsBalanceRestResSchema, propertyEntitySchema, propertyNestedEntitySchema, propertyRestResBaseSchema, propertyRestResSchema, propertySearchRestReqSchema, propertySyncFromAmmozeGrpcReqSchema, queryModeSchema, receiptListReportRestReqSchema, reconcileCmaTransactionRestReqSchema, reconcileMtaTransactionRestReqSchema, reconciledItemsListReportRestReqSchema, safeParseDateFromStr, settlementPayoutPaymentEntitySchema, settlementPayoutProvisionDataEntitySchema, settlementPayoutRestResSchema, settlementPayoutSourceDetailEntitySchema, settlementPayoutTargetDetailEntitySchema, simpleStringFilterSchema, sortReqSchema, stateCodeSchema, statusFilterSchema, statusNullableFilterSchema, stringFilterSchema, stringNullableFilterSchema, stringToBoolSchema, stringToDateSchema, stringToEndOfDaySchema, stringToStartOfDaySchema, trustTrialBalanceReportRestReqSchema, unknownPayoutPaymentEntitySchema, unknownPayoutProvisionDataEntitySchema, unknownPayoutRestResSchema, unknownPayoutSourceDetailEntitySchema, unknownPayoutTargetDetailEntitySchema, unknownReceiptLedgerRestReqSchema, unreconciledItemsListReportRestReqSchema, updateCmaOpenReconciliationCurrentBankStatementBalanceRestReqSchema, updateCmaSettlementPayoutRestReqSchema, updateMenuRestReqSchema, updateMtaRestReqSchema, updateMtaSettlementPayoutRestReqSchema, updateMtaToCmaPayoutRestReqSchema, updateMtaTransactionRestReqSchema, updateOpenReconciliationCurrentBankStatementBalanceRestReqSchema, updateSettlementPayoutRestReqSchema, updateUnknownPayoutRestReqSchema, updateUnknownPayoutTargetDetailRestReqSchema, userEntitySchema, userRestResSchema, validateGetPropertyNameFormat };

package/dist/esm/schemas/mta/create-mta.rest.schema.d.ts

@@ -14,4 +14,5 @@ export declare const createMtaRestReqSchema: z.ZodObject<{
     zeptoBankAccountId: z.ZodUUID;
 }, z.core.$strip>;
 export type CreateMtaRestReq = z.input<typeof createMtaRestReqSchema>;
+export type CreateMtaReq = z.output<typeof createMtaRestReqSchema>;
 //# sourceMappingURL=create-mta.rest.schema.d.ts.map

package/dist/esm/schemas/mta/create-mta.rest.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-mta.rest.schema.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/mta/create-mta.rest.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtG,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;iBAkBjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"create-mta.rest.schema.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/mta/create-mta.rest.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtG,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;iBAkBjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/esm/schemas/mta-account-period/mta-account-period-closing-summary.rest.schema.d.ts

@@ -351,6 +351,7 @@ export declare const mtaAccountPeriodClosingSummaryRestResSchema: z.ZodObject<{
             amountStr?: string | null | undefined;
             transactionNumber?: string | null | undefined;
             isCancelable?: boolean | null | undefined;
+            payout?: z.output<typeof import("..").payoutEntitySchema> | null | undefined;
         }, {
             id: string;
             referenceId: string | null;
@@ -641,6 +642,7 @@ export declare const mtaAccountPeriodClosingSummaryRestResSchema: z.ZodObject<{
                 } | null | undefined;
             } & /*elided*/ any)[] | null | undefined;
             reconciledTransactions?: z.input<typeof import("..").mtaReconciledTransactionRestResSchema>[] | null | undefined;
+            payout?: z.input<typeof import("..").payoutEntitySchema> | null | undefined;
         }, z.core.$ZodTypeInternals<{
             id: string;
             referenceId: string | null;
@@ -941,6 +943,7 @@ export declare const mtaAccountPeriodClosingSummaryRestResSchema: z.ZodObject<{
             amountStr?: string | null | undefined;
             transactionNumber?: string | null | undefined;
             isCancelable?: boolean | null | undefined;
+            payout?: z.output<typeof import("..").payoutEntitySchema> | null | undefined;
         }, {
             id: string;
             referenceId: string | null;
@@ -1231,6 +1234,7 @@ export declare const mtaAccountPeriodClosingSummaryRestResSchema: z.ZodObject<{
                 } | null | undefined;
             } & /*elided*/ any)[] | null | undefined;
             reconciledTransactions?: z.input<typeof import("..").mtaReconciledTransactionRestResSchema>[] | null | undefined;
+            payout?: z.input<typeof import("..").payoutEntitySchema> | null | undefined;
         }>>>>>>;
         unreconciledAmountCents: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodCoercedBigInt<unknown>, z.ZodCoercedNumber<unknown>]>, z.ZodTransform<number, number | bigint>>, z.ZodNumber>;
         unreconciledTransactions: z.ZodOptional<z.ZodNullable<z.ZodLazy<z.ZodArray<z.ZodType<{
@@ -1533,6 +1537,7 @@ export declare const mtaAccountPeriodClosingSummaryRestResSchema: z.ZodObject<{
             amountStr?: string | null | undefined;
             transactionNumber?: string | null | undefined;
             isCancelable?: boolean | null | undefined;
+            payout?: z.output<typeof import("..").payoutEntitySchema> | null | undefined;
         }, {
             id: string;
             referenceId: string | null;
@@ -1823,6 +1828,7 @@ export declare const mtaAccountPeriodClosingSummaryRestResSchema: z.ZodObject<{
                 } | null | undefined;
             } & /*elided*/ any)[] | null | undefined;
             reconciledTransactions?: z.input<typeof import("..").mtaReconciledTransactionRestResSchema>[] | null | undefined;
+            payout?: z.input<typeof import("..").payoutEntitySchema> | null | undefined;
         }, z.core.$ZodTypeInternals<{
             id: string;
             referenceId: string | null;
@@ -2123,6 +2129,7 @@ export declare const mtaAccountPeriodClosingSummaryRestResSchema: z.ZodObject<{
             amountStr?: string | null | undefined;
             transactionNumber?: string | null | undefined;
             isCancelable?: boolean | null | undefined;
+            payout?: z.output<typeof import("..").payoutEntitySchema> | null | undefined;
         }, {
             id: string;
             referenceId: string | null;
@@ -2413,6 +2420,7 @@ export declare const mtaAccountPeriodClosingSummaryRestResSchema: z.ZodObject<{
                 } | null | undefined;
             } & /*elided*/ any)[] | null | undefined;
             reconciledTransactions?: z.input<typeof import("..").mtaReconciledTransactionRestResSchema>[] | null | undefined;
+            payout?: z.input<typeof import("..").payoutEntitySchema> | null | undefined;
         }>>>>>>;
     }, z.core.$strip>;
 }, z.core.$strip>;

package/dist/esm/schemas/mta-account-period/mta-account-period-closing-summary.rest.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mta-account-period-closing-summary.rest.schema.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/mta-account-period/mta-account-period-closing-summary.rest.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,2CAA2C;;;iBAGtD,CAAC;AAEH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,CAAC;AAEhH,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BtD,CAAC;AAEH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,CAAC"}
+{"version":3,"file":"mta-account-period-closing-summary.rest.schema.d.ts","sourceRoot":"","sources":["../../../../packages/schemas/mta-account-period/mta-account-period-closing-summary.rest.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,2CAA2C;;;iBAGtD,CAAC;AAEH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,CAAC;AAEhH,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BtD,CAAC;AAEH,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,CAAC"}