npm - @mikemo-coposit/am-accounting-shared - Versions diffs - 0.0.1 → 0.0.3 - Mend

@mikemo-coposit/am-accounting-shared 0.0.1 → 0.0.3

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 (684) hide show

package/dist/esm/index.mjs ADDED Viewed

@@ -0,0 +1,3214 @@
+import * as __WEBPACK_EXTERNAL_MODULE_zod__ from "zod";
+import * as __WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__ from "@mikemo-coposit/am-zshared";
+import * as __WEBPACK_EXTERNAL_MODULE_dayjs__ from "dayjs";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+var common_utils_namespaceObject = {};
+__webpack_require__.r(common_utils_namespaceObject);
+__webpack_require__.d(common_utils_namespaceObject, {
+    hasBrowserEnv: ()=>hasBrowserEnv,
+    hasStandardBrowserEnv: ()=>hasStandardBrowserEnv,
+    hasStandardBrowserWebWorkerEnv: ()=>hasStandardBrowserWebWorkerEnv,
+    navigator: ()=>_navigator,
+    origin: ()=>utils_origin
+});
+const CMAStatus = {
+    ACTIVE: 'active',
+    INACTIVE: 'inactive'
+};
+var common_status_constant_AccountingCommonStatus = /*#__PURE__*/ function(AccountingCommonStatus) {
+    AccountingCommonStatus["ACTIVE"] = "active";
+    AccountingCommonStatus["INACTIVE"] = "inactive";
+    return AccountingCommonStatus;
+}({});
+const AccountingCommonSyncStatus = {
+    PENDING: 'pending',
+    SYNCED: 'synced',
+    FAILED: 'failed'
+};
+var reconcile_transaction_action_constant_ReconcileTransactionAction = /*#__PURE__*/ function(ReconcileTransactionAction) {
+    ReconcileTransactionAction["RECONCILE"] = "reconcile";
+    ReconcileTransactionAction["UNRECONCILE"] = "unreconcile";
+    return ReconcileTransactionAction;
+}({});
+const MenuStatus = {
+    ACTIVE: 'active',
+    DISABLED: 'disabled'
+};
+const MenuType = {
+    DIRECTORY: 'directory',
+    MENU: 'menu',
+    PERMISSION: 'permission'
+};
+var mta_MtaStatus = /*#__PURE__*/ function(MtaStatus) {
+    MtaStatus["ACTIVE"] = "active";
+    MtaStatus["INACTIVE"] = "inactive";
+    return MtaStatus;
+}({});
+var mta_account_period_constant_MtaAccountPeriodStatus = /*#__PURE__*/ function(MtaAccountPeriodStatus) {
+    MtaAccountPeriodStatus["OPEN"] = "open";
+    MtaAccountPeriodStatus["CLOSED"] = "closed";
+    return MtaAccountPeriodStatus;
+}({});
+var mta_reconciliation_constant_MtaReconciliationStatus = /*#__PURE__*/ function(MtaReconciliationStatus) {
+    MtaReconciliationStatus["FINAL_IN_ACCOUNT_PERIOD"] = "final-in-account-period";
+    MtaReconciliationStatus["COMPLETED"] = "completed";
+    return MtaReconciliationStatus;
+}({});
+var mta_input_type_constant_MtaTransactionInputType = /*#__PURE__*/ function(MtaTransactionInputType) {
+    MtaTransactionInputType["UNKNOWN"] = "unknown";
+    MtaTransactionInputType["CUSTOMER"] = "customer";
+    MtaTransactionInputType["SYSTEM"] = "system";
+    return MtaTransactionInputType;
+}({});
+var mta_payment_method_constant_MtaTransactionPaymentMethod = /*#__PURE__*/ function(MtaTransactionPaymentMethod) {
+    MtaTransactionPaymentMethod["EFT"] = "EFT";
+    return MtaTransactionPaymentMethod;
+}({});
+const MtaReceiptTransactionType = {
+    UNKNOWN: 'unknown',
+    HOLDING_DEPOSIT: 'holding_deposit',
+    SIGNING_DEPOSIT: 'signing_deposit',
+    WEEKLY_PAYMENT: 'weekly_payment',
+    INTEREST: 'interest'
+};
+const ASSIGN_UNKNOWN_TO_CUSTOMER = 'assign_unknown_to_customer';
+const TRANSACTION_CANCEL = 'transaction_cancel';
+const MtaPayoutTransactionType = {
+    TRUST_TO_CMA_PAYOUT: 'trust_to_cma_payout',
+    TRUST_SETTLEMENT_PAYOUT: 'trust_settlement_payout',
+    CMA_SETTLEMENT_PAYOUT: 'cma_settlement_payout',
+    TRUST_REFUND_PAYOUT: 'trust_refund_payout',
+    UNKNOWN_PAYOUT: 'unknown_payout'
+};
+const MtaTransactionType = {
+    ...MtaReceiptTransactionType,
+    ...MtaPayoutTransactionType,
+    ASSIGN_UNKNOWN_TO_CUSTOMER,
+    TRANSACTION_CANCEL
+};
+const MtaTransactionTypeToDisplayTextMapper = {
+    [MtaTransactionType.UNKNOWN]: 'Unknown',
+    [MtaTransactionType.HOLDING_DEPOSIT]: 'Holding Deposit',
+    [MtaTransactionType.SIGNING_DEPOSIT]: 'Signing Deposit',
+    [MtaTransactionType.WEEKLY_PAYMENT]: 'Weekly Payment',
+    [MtaTransactionType.INTEREST]: 'Interest',
+    [MtaTransactionType.TRUST_TO_CMA_PAYOUT]: 'Trust to CMA Payout',
+    [MtaTransactionType.TRUST_SETTLEMENT_PAYOUT]: 'Trust Settlement Payout',
+    [MtaTransactionType.CMA_SETTLEMENT_PAYOUT]: 'CMA Settlement Payout',
+    [MtaTransactionType.TRUST_REFUND_PAYOUT]: 'Trust Refund Payout',
+    [MtaTransactionType.UNKNOWN_PAYOUT]: 'Unknown Payout',
+    [MtaTransactionType.ASSIGN_UNKNOWN_TO_CUSTOMER]: 'Assign Unknown',
+    [MtaTransactionType.TRANSACTION_CANCEL]: 'Cancel Transaction'
+};
+const ProjectMtaAllocationStatus = {
+    PENDING_APPROVAL: 'pending_approval',
+    APPROVED: 'approved',
+    REJECTED: 'rejected'
+};
+const ProjectApplyStatusRestRes = {
+    MISS_MATCH: 'miss_match',
+    PENDING_TRUST_ACCOUNT: 'pending_trust_account',
+    ...ProjectMtaAllocationStatus
+};
+const PropertyRestResStatus = {
+    ACTIVE: 'active'
+};
+const PropertyStage = {
+    INITIAL_DEPOSIT: "initial_deposit",
+    STANDARD_SALE: "standard_sale",
+    COPOSIT_SALE: "coposit_sale"
+};
+const cmaListRestResSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    cmaSeq: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().nonnegative(),
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    balanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint().nonnegative().transform((arg)=>Number(arg) / 100),
+    currentReceiveSeq: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().nonnegative(),
+    currentPayoutSeq: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().nonnegative(),
+    payoutId: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().nonnegative(),
+    stateCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bankCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bsb: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(CMAStatus),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    developerCompanyName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    buyerName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+}).strip();
+const cmaEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    cmaSeq: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().gte(0),
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    balanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    currentReceiveSeq: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().gte(0),
+    currentPayoutSeq: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().gte(0),
+    payoutId: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().gte(0),
+    stateCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bankCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bsb: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(CMAStatus),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    developerCompanyName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional().nullable(),
+    buyerName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional().nullable()
+}).strip();
+const createCMARestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bankCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bsb: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+});
+const cmaTransactionEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    cmaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    sequence: __WEBPACK_EXTERNAL_MODULE_zod__.z.number(),
+    creditAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    debitAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    balanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    createType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bankRef: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional(),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional(),
+    transactionType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().max(50),
+    isCanceled: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(false),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().default(false),
+    clearedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().nullable().optional(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().default(new Date()),
+    syncedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().nullable().optional().default(new Date()),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    cancelSourceId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional(),
+    cancelType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional(),
+    canceledBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional(),
+    canceledAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().nullable().optional(),
+    canceledReason: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable()
+});
+const developerEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    companyName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    syncedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date()
+});
+const createMenuRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    parentId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    label: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    title: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    section: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    icon: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    show: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional().default(true),
+    path: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(MenuType),
+    permissionKey: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().min(1, 'Permission key is required'),
+    sort: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().optional().default(99),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(MenuStatus).default(MenuStatus.ACTIVE)
+});
+const menuSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    parentId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    label: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    title: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    section: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    icon: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    path: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    absolutePath: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(MenuType),
+    permissionKey: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    sort: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().nullish(),
+    show: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().nullish(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(MenuStatus),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean()
+});
+const menuRestResSchema = menuSchema.extend({
+    children: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(menuSchema).optional()
+});
+const updateMenuRestReqSchema = createMenuRestReqSchema.extend({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+});
+const createMtaRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().trim().min(1),
+    country: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().refine((val)=>'Australia' === val, {
+        message: 'Country must be Australia'
+    }),
+    stateCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(__WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__.AuStateCode),
+    bankCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(__WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__.AuTrustAccountBankCode),
+    bsb: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().length(6).regex(/^\d+$/, {
+        message: 'BSB must be all digits'
+    }),
+    accountNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().min(6).max(10).regex(/^\d+$/, {
+        message: 'Account number must be all digits'
+    }),
+    directDebitBankAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    directDebitProviderCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(__WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__.PaymentProviderCode),
+    payIdBankAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    payIdProviderCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(__WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__.PaymentProviderCode),
+    zeptoBankAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid()
+});
+const mtaEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    country: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    stateCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bankCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    subsidiaryId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bsb: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    balanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    currentReceiveSeq: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int(),
+    currentPayoutSeq: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    syncedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    updatedBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable()
+});
+const maskString = (input, options = {})=>{
+    if (!input) return '';
+    const { visibleStart = 0, visibleEnd = 2, maskChar = '*' } = options;
+    const length = input.length;
+    if (length <= 2) return input;
+    const maxVisible = length - 2;
+    const actualVisibleStart = Math.min(visibleStart, maxVisible - visibleEnd);
+    const actualVisibleEnd = Math.min(visibleEnd, maxVisible - actualVisibleStart);
+    const start = input.slice(0, actualVisibleStart);
+    const end = input.slice(-actualVisibleEnd);
+    const masked = maskChar.repeat(length - actualVisibleStart - actualVisibleEnd);
+    return start + masked + end;
+};
+const mtaAccountPeriodEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    startDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    endDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    openingBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    closingBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint().nullable(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    closedBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    closedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    closingDescription: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable()
+});
+const paymentProviderEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    providerCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    settings: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date()
+});
+const mtaPaymentMethodAccountConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    bsb: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    credential: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        bankAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+    })
+});
+const mtaPaymentMethodFloatAccountConfigSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    domainName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().email(),
+    credential: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        bankAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+    })
+});
+const mtaPaymentMethodEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    paymentProviderId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    bankAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    account: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    floatAccount: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date()
+});
+const mtaPaymentMethodRestResSchema = mtaPaymentMethodEntitySchema.extend({
+    paymentProvider: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>paymentProviderEntitySchema).optional(),
+    mta: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaEntitySchema).optional(),
+    account: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().transform((val)=>{
+        if ('string' == typeof val) return JSON.parse(val);
+        return val;
+    }).pipe(mtaPaymentMethodAccountConfigSchema),
+    floatAccount: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().transform((val)=>{
+        if ('string' == typeof val) return JSON.parse(val);
+        return val;
+    }).pipe(mtaPaymentMethodFloatAccountConfigSchema).nullish()
+}).strip();
+const mtaReconciliationEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    mtaAccountPeriodId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    closingBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint().nullable(),
+    reconciledTo: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    reconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint().nullable(),
+    unreconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint().nullable(),
+    totalReconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint().nullable(),
+    bankStatementBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    closingVarianceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint().nullable(),
+    closedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    closedBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    editable: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean()
+});
+const mtaReconciliationRestResSchema = mtaReconciliationEntitySchema.extend({
+    closingBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()).nullish(),
+    bankStatementBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    closingVarianceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()).nullish(),
+    currentTrustBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()).nullish(),
+    currentReconciledBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()).nullish(),
+    currentVarianceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()).nullish()
+});
+const mtaRestResSchema = mtaEntitySchema.extend({
+    stateCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(__WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__.AuStateCode),
+    bankCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(__WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__.AuTrustAccountBankCode),
+    accountNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().transform((arg)=>maskString(arg, {
+            visibleStart: 0,
+            visibleEnd: 2
+        })),
+    bsb: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().transform((arg)=>maskString(arg, {
+            visibleStart: 0,
+            visibleEnd: 3
+        })?.replace(/^(\*+)(\d{3})$/, '$1-$2')),
+    subsidiaryId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    balanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    paymentMethods: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>__WEBPACK_EXTERNAL_MODULE_zod__.z.array(mtaPaymentMethodRestResSchema)).optional(),
+    accountPeriods: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaAccountPeriodEntitySchema.array().optional())
+});
+const mtaListItemRestResSchema = mtaRestResSchema.omit({
+    paymentMethods: true,
+    accountPeriods: true
+}).extend({
+    currentReconciliation: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaReconciliationRestResSchema).nullish()
+});
+const updateMtaRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().trim().min(1)
+}).strip();
+const mtaAccountPeriodCloseRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    mtaAccountPeriodId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    endDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.date()
+    ]).transform((date)=>(0, __WEBPACK_EXTERNAL_MODULE_dayjs__["default"])(date).endOf('day').toDate()).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.date()),
+    closingDescription: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional()
+});
+const fromCentsToDollars = (amount)=>Number(amount) / 100;
+const fromDollarsToCents = (amount)=>100n * BigInt(amount);
+const formatCurrency = (amount, options)=>{
+    const { locale = 'en-AU', defaultValue = null, currency = 'AUD', style = 'currency', ...rest } = options || {};
+    const num = Number(amount);
+    if (null == amount || Number.isNaN(num)) return defaultValue;
+    return num.toLocaleString(locale, {
+        style,
+        currency,
+        ...rest
+    });
+};
+const isUnknownTransaction = (transaction)=>transaction.transactionType === MtaTransactionType.UNKNOWN;
+const isReceiptTransaction = (transaction)=>Object.values(MtaReceiptTransactionType).includes(transaction.transactionType);
+const isPaymentTransaction = (transaction)=>Object.values(MtaPayoutTransactionType).includes(transaction.transactionType);
+const getTransactionAmountStr = (transaction)=>{
+    if (!transaction) return;
+    const debitAmountCents = Number(transaction.debitAmountCents);
+    const creditAmountCents = Number(transaction.creditAmountCents);
+    const amount = debitAmountCents > 0 ? 0 - debitAmountCents : creditAmountCents;
+    if (0 === amount) return;
+    return formatCurrency(amount);
+};
+const isUnknownReceiptAssignedToProperty = (transaction)=>{
+    if (transaction.transactionType !== MtaTransactionType.UNKNOWN) return null;
+    const index = (transaction.subsequentTransactions || []).findIndex((item)=>item.inputType === mta_input_type_constant_MtaTransactionInputType.CUSTOMER);
+    if (index > -1) return true;
+    return false;
+};
+const isTransactionCancelable = (transaction)=>{
+    const isUnkonwn = isUnknownTransaction(transaction);
+    if (true !== isUnkonwn) return {
+        isCancelable: false,
+        reason: 'Transaction is not unknown'
+    };
+    if (transaction.isCanceled) return {
+        isCancelable: false,
+        reason: 'Transaction is already canceled'
+    };
+    if (transaction.isRefunded) return {
+        isCancelable: false,
+        reason: 'Transaction is already refunded'
+    };
+    if (isUnkonwn && transaction.transactionType === MtaTransactionType.TRANSACTION_CANCEL) return {
+        isCancelable: false,
+        reason: 'Cannot cancel cancel transaction'
+    };
+    if (isUnkonwn && transaction.transactionType === MtaTransactionType.TRANSACTION_CANCEL) return {
+        isCancelable: false,
+        reason: 'Cannot cancel assign unknown transaction'
+    };
+    return {
+        isCancelable: true
+    };
+};
+const isTransactionAssignable = (transaction)=>{
+    const isUnkonwn = isUnknownTransaction(transaction);
+    if (true !== isUnkonwn) return {
+        isAssignable: false,
+        reason: 'Only unknown transaction can be assigned to property'
+    };
+    if (transaction.isCanceled) return {
+        isAssignable: false,
+        reason: 'Transaction is canceled'
+    };
+    if (transaction.isRefunded) return {
+        isAssignable: false,
+        reason: 'Transaction is refunded'
+    };
+    if (isUnkonwn && transaction.transactionType === MtaTransactionType.TRANSACTION_CANCEL) return {
+        isAssignable: false,
+        reason: 'Cannot assign to property cancel transaction'
+    };
+    if (isUnkonwn && transaction.transactionType === MtaTransactionType.ASSIGN_UNKNOWN_TO_CUSTOMER) return {
+        isAssignable: false,
+        reason: 'Transaction is already assigned to property'
+    };
+    return {
+        isAssignable: true
+    };
+};
+const getTransactionNumber = (transaction)=>{
+    if (transaction.transactionType === MtaTransactionType.TRANSACTION_CANCEL) return `(${transaction.sequence})`;
+    return `${transaction.sequence}`;
+};
+const getTransactionStatus = (transaction)=>{
+    const isReceipt = isReceiptTransaction(transaction);
+    const isPayment = isPaymentTransaction(transaction);
+    const isUnknown = isUnknownTransaction(transaction);
+    const isAssignableToProperty = isTransactionAssignable(transaction);
+    const isAssignedToProperty = isUnknownReceiptAssignedToProperty(transaction);
+    const amountStr = getTransactionAmountStr(transaction);
+    const transactionNumber = getTransactionNumber(transaction);
+    const isCancelable = isTransactionCancelable(transaction);
+    const isReconciled = transaction.reconciledTransactions?.length ? transaction.reconciledTransactions.length > 0 : false;
+    return {
+        isReceipt,
+        isPayment,
+        isUnknown,
+        isAssignableToProperty: isAssignableToProperty.isAssignable,
+        isAssignedToProperty,
+        amountStr,
+        transactionNumber,
+        isCancelable: isCancelable.isCancelable,
+        isReconciled
+    };
+};
+const mtaAccountPeriodRestResBaseSchema = mtaAccountPeriodEntitySchema.extend({
+    openingBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    closingBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).nullish().transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number())
+});
+const mtaAccountPeriodRestResSchema = mtaAccountPeriodRestResBaseSchema.extend({
+    mta: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaRestResSchema).optional(),
+    reconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()).nullish(),
+    totalReconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()).nullish(),
+    unreconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()).nullish()
+});
+const mtaClosedAccountPeriodRestResSchema = mtaAccountPeriodRestResSchema.omit({
+    mta: true
+}).extend({
+    currentReconciliation: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaReconciliationRestResSchema).nullish()
+});
+const mtaReconciledTransactionEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    mtaTransactionId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    accountPeriodId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    reconciledByReconciliationId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    reconciledAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date()
+});
+const mtaReconciledTransactionRestResBaseSchema = mtaReconciledTransactionEntitySchema.extend({});
+const mtaReconciledTransactionRestResSchema = mtaReconciledTransactionRestResBaseSchema.extend({
+    mtaTransaction: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaTransactionRestResSchema).nullish(),
+    accountPeriod: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaAccountPeriodRestResSchema).nullish()
+});
+const userEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    email: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    firstName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    lastName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    mobile: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    avatar: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    password: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    passwordVersion: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int(),
+    isTwoFaRequired: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    preferTwoFaMethod: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    twoFaAvailableMethods: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().array(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date()
+});
+const projectMtaAllocationEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    projectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    applyStatus: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(ProjectMtaAllocationStatus),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(common_status_constant_AccountingCommonStatus),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    approvedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    approvedBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    lastSyncedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    syncStatus: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(AccountingCommonSyncStatus).optional().nullish(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean()
+});
+const projectMtaAllocationRestResSchema = projectMtaAllocationEntitySchema.extend({
+    mta: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaRestResSchema.pick({
+            id: true,
+            name: true,
+            stateCode: true,
+            bankCode: true,
+            accountNumber: true,
+            bsb: true
+        })),
+    creator: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>userEntitySchema.pick({
+            id: true,
+            firstName: true,
+            lastName: true
+        })),
+    approver: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>userEntitySchema.pick({
+            id: true,
+            firstName: true,
+            lastName: true
+        })).optional()
+});
+const projectEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    developerId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    state: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(__WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__.AuStateCode),
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    syncedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date()
+});
+const projectRestResSchema = projectEntitySchema.extend({
+    developer: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>developerEntitySchema).optional().nullish(),
+    mta: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaRestResSchema).optional().nullish(),
+    mtaAllocations: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>projectMtaAllocationRestResSchema.array()).optional().nullish(),
+    applyStatus: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(ProjectApplyStatusRestRes)
+});
+const propertyEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    customerId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    projectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    buyerName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional().nullable(),
+    lotDetail: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    propertyAddress: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    balanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]),
+    cmaBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]),
+    mtaBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]),
+    stage: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(PropertyStage),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(PropertyRestResStatus),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    syncedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date()
+});
+const propertyListRestResSchema = propertyEntitySchema.extend({
+    customerEmail: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    customerMobile: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    projectType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(PropertyRestResStatus),
+    stage: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(__WEBPACK_EXTERNAL_MODULE__mikemo_coposit_am_zshared_87ea352e__.PropertyStage),
+    projectName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    propertyName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    propertyAddress: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    hasCMA: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    developerId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    developerCompanyName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    cma: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>cmaEntitySchema).optional().nullish()
+}).strip();
+const propertyRestResSchema = propertyEntitySchema.extend({
+    project: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>projectRestResSchema.omit({
+            applyStatus: true,
+            mtaAllocations: true,
+            mta: true
+        })).nullish(),
+    mta: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaRestResSchema).nullish(),
+    cma: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>cmaListRestResSchema).nullish()
+});
+const mtaTransactionEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    referenceId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    sequence: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int(),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    inputType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    transactionType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    creditAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    debitAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    balanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+    bankRef: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isRefunded: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    isCanceled: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    clearedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    syncedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    note: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    sourceTransactionId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    cancelType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    canceledBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    canceledAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    canceledReason: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid().nullable()
+});
+const baseSchema = mtaTransactionEntitySchema.extend({
+    creditAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    debitAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    balanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    inputType: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(mta_input_type_constant_MtaTransactionInputType),
+    transactionType: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(MtaTransactionType),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(common_status_constant_AccountingCommonStatus),
+    creator: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>userEntitySchema).optional().nullish(),
+    canceler: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>userEntitySchema).optional().nullish(),
+    property: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>propertyRestResSchema.omit({
+            mta: true,
+            cma: true
+        })).optional().nullish()
+});
+const mtaTransactionRestResSchema = baseSchema.extend({
+    mta: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaRestResSchema).nullish(),
+    sourceTransaction: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaTransactionRestResSchema).nullish(),
+    subsequentTransactions: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaTransactionRestResSchema.array()).nullish(),
+    reconciledTransactions: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaReconciledTransactionRestResSchema.array()).nullish(),
+    isUnknown: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional(),
+    isReceipt: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional(),
+    isPayment: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional(),
+    isReconciled: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().optional(),
+    isAssignableToProperty: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().nullish(),
+    isAssignedToProperty: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().nullish(),
+    isCancelable: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().nullish(),
+    amountStr: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    transactionNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional()
+}).transform((obj)=>{
+    const { isUnknown, isAssignedToProperty, isReceipt, isPayment, isAssignableToProperty, amountStr, transactionNumber } = getTransactionStatus(obj);
+    return {
+        ...obj,
+        isUnknown,
+        isReceipt,
+        isPayment,
+        isAssignableToProperty,
+        isAssignedToProperty,
+        amountStr,
+        transactionNumber
+    };
+});
+const mtaAccountPeriodClosingSummaryRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    mtaAccountPeriodId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    endDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.date()
+    ]).transform((arg)=>(0, __WEBPACK_EXTERNAL_MODULE_dayjs__["default"])(arg).endOf('day').toDate()).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.date())
+});
+const mtaAccountPeriodClosingSummaryRestResSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    startDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    endDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    bankStatementBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    currentTrustBalanceSummary: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        totalAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalCreditAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalDebitAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalTransactionsCount: __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    }),
+    reconciliations: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaReconciliationRestResSchema.array()).nullish(),
+    totalReconciledAmountSummary: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        totalReconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalReconciledCreditAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalReconciledDebitAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalReconciledTransactionsCount: __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    }),
+    totalUnreconciledAmountSummary: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        totalUnreconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalUnreconciledCreditAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalUnreconciledDebitAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        totalUnreconciledTransactionsCount: __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    }),
+    transactionsSummary: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        reconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        reconciledTransactions: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaTransactionRestResSchema.array()).nullish(),
+        unreconciledAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+            __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+        ]).transform(fromCentsToDollars).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+        unreconciledTransactions: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaTransactionRestResSchema.array()).nullish()
+    })
+});
+const updateMtaAccountPeriodReconciledToRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    mtaAccountPeriodId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    reconciledTo: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.date()
+    ]).transform((arg)=>(0, __WEBPACK_EXTERNAL_MODULE_dayjs__["default"])(arg).endOf('day').toDate()),
+    bankStatementBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().transform((arg)=>100n * BigInt(arg)).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.bigint()),
+    lastUpdatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string().datetime(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.date()
+    ]).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date())
+});
+const createMtaReconciliationRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    bankStatementBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>100n * BigInt(arg)).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.bigint()),
+    reconciledTo: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.date()
+    ]).transform((arg)=>(0, __WEBPACK_EXTERNAL_MODULE_dayjs__["default"])(arg).endOf('day').toDate()).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date()),
+    mtaAccountPeriodId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid()
+});
+const updateOpenReconciliationCurrentBankStatementBalanceRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    mtaReconciliationId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    bankStatementBalanceCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint()
+    ]).transform((arg)=>'bigint' == typeof arg ? arg : 100n * BigInt(arg)).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.bigint())
+});
+const assignUnknownReceiptToPropertyRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    mtaTransactionId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    transactionType: __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+        MtaReceiptTransactionType.HOLDING_DEPOSIT,
+        MtaReceiptTransactionType.SIGNING_DEPOSIT,
+        MtaReceiptTransactionType.WEEKLY_PAYMENT
+    ]),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().transform((val)=>val.trim())
+});
+const cancelMtaTransactionRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    transactionId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().transform((val)=>val.trim()).nullish(),
+    reason: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().transform((val)=>val.trim()).nullish()
+});
+const createMtaTransactionRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    amount: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().positive().transform((val)=>100n * BigInt(val)).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.bigint()),
+    clearedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().transform((val)=>val.toISOString().split('T')[0]),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().transform((val)=>val.trim()),
+    inputType: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(mta_input_type_constant_MtaTransactionInputType),
+    transactionType: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(MtaTransactionType),
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid().optional(),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    bankRef: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().transform((val)=>val.trim()),
+    paymentMethod: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(mta_payment_method_constant_MtaTransactionPaymentMethod),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string().length(0)
+    ]).transform((val)=>'' === val ? mta_payment_method_constant_MtaTransactionPaymentMethod.EFT : val).default(mta_payment_method_constant_MtaTransactionPaymentMethod.EFT)
+}).superRefine((data, ctx)=>{
+    if (data.inputType !== mta_input_type_constant_MtaTransactionInputType.UNKNOWN && !data.transactionType) ctx.addIssue({
+        code: __WEBPACK_EXTERNAL_MODULE_zod__.z.ZodIssueCode.custom,
+        message: 'transactionType is required unless is "unknown" receipt',
+        path: [
+            'transactionType'
+        ]
+    });
+    if (data.inputType === mta_input_type_constant_MtaTransactionInputType.CUSTOMER && !data.propertyId) ctx.addIssue({
+        code: __WEBPACK_EXTERNAL_MODULE_zod__.z.ZodIssueCode.custom,
+        message: 'property is required unless is "unknown" receipt',
+        path: [
+            'inputType'
+        ]
+    });
+});
+const reconcileMtaTransactionRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    mtaTransactionId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    reconciliationId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    action: __WEBPACK_EXTERNAL_MODULE_zod__.z.nativeEnum(reconcile_transaction_action_constant_ReconcileTransactionAction)
+});
+const payoutSourceDetailsSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    sourceAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    transactionType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    creditAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string().regex(/^\d+$/).transform((val)=>BigInt(val))
+    ]),
+    debitAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.string().regex(/^\d+$/).transform((val)=>BigInt(val))
+    ]),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional()
+}).catchall(__WEBPACK_EXTERNAL_MODULE_zod__.z.unknown());
+const payoutTargetDetailsSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    toAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    toAccountType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional(),
+    creditAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]),
+    debitAmountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable().optional()
+}).catchall(__WEBPACK_EXTERNAL_MODULE_zod__.z.unknown());
+const provisionDetailsSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    sourceDetails: payoutSourceDetailsSchema,
+    targetDetails: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(payoutTargetDetailsSchema)
+});
+const payoutEntitySchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    sequence: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int(),
+    payoutType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    sourceAccountType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    sourceAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    amountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    createdBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    updatedBy: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    provisionDetails: provisionDetailsSchema
+}).strip();
+const payoutTransactionSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    payoutId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    mainTrustTransactionId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    cmaTransactionId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    isCanceled: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    canceledAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date().nullable(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.coerce.date(),
+    isArchived: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    targetAccountDetails: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    bankRef: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable()
+}).strip();
+const CreatePayoutSchema = payoutEntitySchema.omit({
+    id: true,
+    createdAt: true,
+    updatedAt: true,
+    updatedBy: true,
+    isArchived: true
+});
+const basePayoutItemShape = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional().nullable(),
+    accountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional().nullable(),
+    targetAccountType: __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+        'CMA',
+        'BANK'
+    ])
+});
+const payoutItemReqSchema = basePayoutItemShape.extend({
+    amount: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint()
+    ]).transform((arg)=>Math.round(100 * Number(arg))).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number())
+});
+const payoutRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    payoutType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    sourceAccountId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    totalAmount: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint()
+    ]).transform((arg)=>Math.round(100 * Number(arg))).transform((arg)=>BigInt(arg)).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.bigint()),
+    payoutItems: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(payoutItemReqSchema)
+}).strip();
+const payoutRestResSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    totalFromAccountUpdatedNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().nonnegative(),
+    totalToAccountUpdatedNumber: __WEBPACK_EXTERNAL_MODULE_zod__.z.number().int().nonnegative(),
+    totalAmount: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number())
+}).strip();
+const payoutListRestResSchema = payoutEntitySchema.extend({
+    payoutType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    fromState: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    fromBank: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    fromAccount: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().datetime(),
+    totalAmount: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number()),
+    abaStatus: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+}).strip();
+const payoutPaymentItemSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    propertyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    propertyName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    customerName: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    targetAccount: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    amountCents: __WEBPACK_EXTERNAL_MODULE_zod__.z.union([
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.bigint(),
+        __WEBPACK_EXTERNAL_MODULE_zod__.z.number()
+    ]).transform((arg)=>Number(arg) / 100).pipe(__WEBPACK_EXTERNAL_MODULE_zod__.z.number())
+});
+const payoutDetailRestResSchema = payoutEntitySchema.omit({
+    provisionDetails: true
+}).extend({
+    fileContent: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional().nullable(),
+    mta: __WEBPACK_EXTERNAL_MODULE_zod__.z.lazy(()=>mtaEntitySchema).optional().nullable(),
+    paymentList: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(payoutPaymentItemSchema).optional()
+});
+const allocateMtaToProjectRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    projectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    mtaId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid()
+});
+const approveMtaAllocationRestReqSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    projectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid(),
+    projectMtaAllocationId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().uuid()
+});
+function bind(fn, thisArg) {
+    return function() {
+        return fn.apply(thisArg, arguments);
+    };
+}
+const { toString: utils_toString } = Object.prototype;
+const { getPrototypeOf } = Object;
+const { iterator: utils_iterator, toStringTag } = Symbol;
+const kindOf = ((cache)=>(thing)=>{
+        const str = utils_toString.call(thing);
+        return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+    })(Object.create(null));
+const kindOfTest = (type)=>{
+    type = type.toLowerCase();
+    return (thing)=>kindOf(thing) === type;
+};
+const typeOfTest = (type)=>(thing)=>typeof thing === type;
+const { isArray } = Array;
+const isUndefined = typeOfTest('undefined');
+function isBuffer(val) {
+    return null !== val && !isUndefined(val) && null !== val.constructor && !isUndefined(val.constructor) && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+}
+const isArrayBuffer = kindOfTest('ArrayBuffer');
+function isArrayBufferView(val) {
+    let result;
+    result = 'undefined' != typeof ArrayBuffer && ArrayBuffer.isView ? ArrayBuffer.isView(val) : val && val.buffer && isArrayBuffer(val.buffer);
+    return result;
+}
+const isString = typeOfTest('string');
+const isFunction = typeOfTest('function');
+const isNumber = typeOfTest('number');
+const isObject = (thing)=>null !== thing && 'object' == typeof thing;
+const isBoolean = (thing)=>true === thing || false === thing;
+const isPlainObject = (val)=>{
+    if ('object' !== kindOf(val)) return false;
+    const prototype = getPrototypeOf(val);
+    return (null === prototype || prototype === Object.prototype || null === Object.getPrototypeOf(prototype)) && !(toStringTag in val) && !(utils_iterator in val);
+};
+const isDate = kindOfTest('Date');
+const isFile = kindOfTest('File');
+const isBlob = kindOfTest('Blob');
+const utils_isFileList = kindOfTest('FileList');
+const isStream = (val)=>isObject(val) && isFunction(val.pipe);
+const utils_isFormData = (thing)=>{
+    let kind;
+    return thing && ('function' == typeof FormData && thing instanceof FormData || isFunction(thing.append) && ('formdata' === (kind = kindOf(thing)) || 'object' === kind && isFunction(thing.toString) && '[object FormData]' === thing.toString()));
+};
+const isURLSearchParams = kindOfTest('URLSearchParams');
+const [isReadableStream, isRequest, isResponse, isHeaders] = [
+    'ReadableStream',
+    'Request',
+    'Response',
+    'Headers'
+].map(kindOfTest);
+const trim = (str)=>str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+function forEach(obj, fn, { allOwnKeys = false } = {}) {
+    if (null == obj) return;
+    let i;
+    let l;
+    if ('object' != typeof obj) obj = [
+        obj
+    ];
+    if (isArray(obj)) for(i = 0, l = obj.length; i < l; i++)fn.call(null, obj[i], i, obj);
+    else {
+        const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
+        const len = keys.length;
+        let key;
+        for(i = 0; i < len; i++){
+            key = keys[i];
+            fn.call(null, obj[key], key, obj);
+        }
+    }
+}
+function findKey(obj, key) {
+    key = key.toLowerCase();
+    const keys = Object.keys(obj);
+    let i = keys.length;
+    let _key;
+    while(i-- > 0){
+        _key = keys[i];
+        if (key === _key.toLowerCase()) return _key;
+    }
+    return null;
+}
+const _global = (()=>{
+    if ("undefined" != typeof globalThis) return globalThis;
+    return "undefined" != typeof self ? self : 'undefined' != typeof window ? window : global;
+})();
+const isContextDefined = (context)=>!isUndefined(context) && context !== _global;
+function utils_merge() {
+    const { caseless } = 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;
+    };
+    for(let i = 0, l = arguments.length; i < l; i++)arguments[i] && forEach(arguments[i], assignValue);
+    return result;
+}
+const extend = (a, b, thisArg, { allOwnKeys } = {})=>{
+    forEach(b, (val, key)=>{
+        if (thisArg && isFunction(val)) a[key] = bind(val, thisArg);
+        else a[key] = val;
+    }, {
+        allOwnKeys
+    });
+    return a;
+};
+const stripBOM = (content)=>{
+    if (0xFEFF === content.charCodeAt(0)) content = content.slice(1);
+    return content;
+};
+const inherits = (constructor, superConstructor, props, descriptors)=>{
+    constructor.prototype = Object.create(superConstructor.prototype, descriptors);
+    constructor.prototype.constructor = constructor;
+    Object.defineProperty(constructor, 'super', {
+        value: superConstructor.prototype
+    });
+    props && Object.assign(constructor.prototype, props);
+};
+const toFlatObject = (sourceObj, destObj, filter, propFilter)=>{
+    let props;
+    let i;
+    let prop;
+    const merged = {};
+    destObj = destObj || {};
+    if (null == sourceObj) return destObj;
+    do {
+        props = Object.getOwnPropertyNames(sourceObj);
+        i = props.length;
+        while(i-- > 0){
+            prop = props[i];
+            if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
+                destObj[prop] = sourceObj[prop];
+                merged[prop] = true;
+            }
+        }
+        sourceObj = false !== filter && getPrototypeOf(sourceObj);
+    }while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
+    return destObj;
+};
+const endsWith = (str, searchString, position)=>{
+    str = String(str);
+    if (void 0 === position || position > str.length) position = str.length;
+    position -= searchString.length;
+    const lastIndex = str.indexOf(searchString, position);
+    return -1 !== lastIndex && lastIndex === position;
+};
+const toArray = (thing)=>{
+    if (!thing) return null;
+    if (isArray(thing)) return thing;
+    let i = thing.length;
+    if (!isNumber(i)) return null;
+    const arr = new Array(i);
+    while(i-- > 0)arr[i] = thing[i];
+    return arr;
+};
+const isTypedArray = ((TypedArray)=>(thing)=>TypedArray && thing instanceof TypedArray)('undefined' != typeof Uint8Array && getPrototypeOf(Uint8Array));
+const forEachEntry = (obj, fn)=>{
+    const generator = obj && obj[utils_iterator];
+    const _iterator = generator.call(obj);
+    let result;
+    while((result = _iterator.next()) && !result.done){
+        const pair = result.value;
+        fn.call(obj, pair[0], pair[1]);
+    }
+};
+const matchAll = (regExp, str)=>{
+    let matches;
+    const arr = [];
+    while(null !== (matches = regExp.exec(str)))arr.push(matches);
+    return arr;
+};
+const isHTMLForm = kindOfTest('HTMLFormElement');
+const toCamelCase = (str)=>str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function(m, p1, p2) {
+        return p1.toUpperCase() + p2;
+    });
+const utils_hasOwnProperty = (({ hasOwnProperty })=>(obj, prop)=>hasOwnProperty.call(obj, prop))(Object.prototype);
+const isRegExp = kindOfTest('RegExp');
+const reduceDescriptors = (obj, reducer)=>{
+    const descriptors = Object.getOwnPropertyDescriptors(obj);
+    const reducedDescriptors = {};
+    forEach(descriptors, (descriptor, name)=>{
+        let ret;
+        if (false !== (ret = reducer(descriptor, name, obj))) reducedDescriptors[name] = ret || descriptor;
+    });
+    Object.defineProperties(obj, reducedDescriptors);
+};
+const freezeMethods = (obj)=>{
+    reduceDescriptors(obj, (descriptor, name)=>{
+        if (isFunction(obj) && -1 !== [
+            'arguments',
+            'caller',
+            'callee'
+        ].indexOf(name)) return false;
+        const value = obj[name];
+        if (!isFunction(value)) return;
+        descriptor.enumerable = false;
+        if ('writable' in descriptor) {
+            descriptor.writable = false;
+            return;
+        }
+        if (!descriptor.set) descriptor.set = ()=>{
+            throw Error('Can not rewrite read-only method \'' + name + '\'');
+        };
+    });
+};
+const toObjectSet = (arrayOrString, delimiter)=>{
+    const obj = {};
+    const define = (arr)=>{
+        arr.forEach((value)=>{
+            obj[value] = true;
+        });
+    };
+    isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
+    return obj;
+};
+const noop = ()=>{};
+const toFiniteNumber = (value, defaultValue)=>null != value && Number.isFinite(value *= 1) ? value : defaultValue;
+function isSpecCompliantForm(thing) {
+    return !!(thing && isFunction(thing.append) && 'FormData' === thing[toStringTag] && thing[utils_iterator]);
+}
+const toJSONObject = (obj)=>{
+    const stack = new Array(10);
+    const visit = (source, i)=>{
+        if (isObject(source)) {
+            if (stack.indexOf(source) >= 0) return;
+            if (!('toJSON' in source)) {
+                stack[i] = source;
+                const target = isArray(source) ? [] : {};
+                forEach(source, (value, key)=>{
+                    const reducedValue = visit(value, i + 1);
+                    isUndefined(reducedValue) || (target[key] = reducedValue);
+                });
+                stack[i] = void 0;
+                return target;
+            }
+        }
+        return source;
+    };
+    return visit(obj, 0);
+};
+const isAsyncFn = kindOfTest('AsyncFunction');
+const isThenable = (thing)=>thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
+const _setImmediate = ((setImmediateSupported, postMessageSupported)=>{
+    if (setImmediateSupported) return setImmediate;
+    return postMessageSupported ? ((token, callbacks)=>{
+        _global.addEventListener("message", ({ source, data })=>{
+            if (source === _global && data === token) callbacks.length && callbacks.shift()();
+        }, false);
+        return (cb)=>{
+            callbacks.push(cb);
+            _global.postMessage(token, "*");
+        };
+    })(`axios@${Math.random()}`, []) : (cb)=>setTimeout(cb);
+})('function' == typeof setImmediate, isFunction(_global.postMessage));
+const asap = 'undefined' != typeof queueMicrotask ? queueMicrotask.bind(_global) : 'undefined' != typeof process && process.nextTick || _setImmediate;
+const isIterable = (thing)=>null != thing && isFunction(thing[utils_iterator]);
+const utils = {
+    isArray,
+    isArrayBuffer,
+    isBuffer,
+    isFormData: utils_isFormData,
+    isArrayBufferView,
+    isString,
+    isNumber,
+    isBoolean,
+    isObject,
+    isPlainObject,
+    isReadableStream,
+    isRequest,
+    isResponse,
+    isHeaders,
+    isUndefined,
+    isDate,
+    isFile,
+    isBlob,
+    isRegExp,
+    isFunction,
+    isStream,
+    isURLSearchParams,
+    isTypedArray,
+    isFileList: utils_isFileList,
+    forEach,
+    merge: utils_merge,
+    extend,
+    trim,
+    stripBOM,
+    inherits,
+    toFlatObject,
+    kindOf,
+    kindOfTest,
+    endsWith,
+    toArray,
+    forEachEntry,
+    matchAll,
+    isHTMLForm,
+    hasOwnProperty: utils_hasOwnProperty,
+    hasOwnProp: utils_hasOwnProperty,
+    reduceDescriptors,
+    freezeMethods,
+    toObjectSet,
+    toCamelCase,
+    noop,
+    toFiniteNumber,
+    findKey,
+    global: _global,
+    isContextDefined,
+    isSpecCompliantForm,
+    toJSONObject,
+    isAsyncFn,
+    isThenable,
+    setImmediate: _setImmediate,
+    asap,
+    isIterable
+};
+function AxiosError(message, code, config, request, response) {
+    Error.call(this);
+    if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+    else this.stack = new Error().stack;
+    this.message = message;
+    this.name = 'AxiosError';
+    code && (this.code = code);
+    config && (this.config = config);
+    request && (this.request = request);
+    if (response) {
+        this.response = response;
+        this.status = response.status ? response.status : null;
+    }
+}
+utils.inherits(AxiosError, Error, {
+    toJSON: function() {
+        return {
+            message: this.message,
+            name: this.name,
+            description: this.description,
+            number: this.number,
+            fileName: this.fileName,
+            lineNumber: this.lineNumber,
+            columnNumber: this.columnNumber,
+            stack: this.stack,
+            config: utils.toJSONObject(this.config),
+            code: this.code,
+            status: this.status
+        };
+    }
+});
+const AxiosError_prototype = AxiosError.prototype;
+const AxiosError_descriptors = {};
+[
+    'ERR_BAD_OPTION_VALUE',
+    'ERR_BAD_OPTION',
+    'ECONNABORTED',
+    'ETIMEDOUT',
+    'ERR_NETWORK',
+    'ERR_FR_TOO_MANY_REDIRECTS',
+    'ERR_DEPRECATED',
+    'ERR_BAD_RESPONSE',
+    'ERR_BAD_REQUEST',
+    'ERR_CANCELED',
+    'ERR_NOT_SUPPORT',
+    'ERR_INVALID_URL'
+].forEach((code)=>{
+    AxiosError_descriptors[code] = {
+        value: code
+    };
+});
+Object.defineProperties(AxiosError, AxiosError_descriptors);
+Object.defineProperty(AxiosError_prototype, 'isAxiosError', {
+    value: true
+});
+AxiosError.from = (error, code, config, request, response, customProps)=>{
+    const axiosError = Object.create(AxiosError_prototype);
+    utils.toFlatObject(error, axiosError, function(obj) {
+        return obj !== Error.prototype;
+    }, (prop)=>'isAxiosError' !== prop);
+    AxiosError.call(axiosError, error.message, code, config, request, response);
+    axiosError.cause = error;
+    axiosError.name = error.name;
+    customProps && Object.assign(axiosError, customProps);
+    return axiosError;
+};
+const core_AxiosError = AxiosError;
+const helpers_null = null;
+function isVisitable(thing) {
+    return utils.isPlainObject(thing) || utils.isArray(thing);
+}
+function removeBrackets(key) {
+    return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;
+}
+function renderKey(path, key, dots) {
+    if (!path) return key;
+    return path.concat(key).map(function(token, i) {
+        token = removeBrackets(token);
+        return !dots && i ? '[' + token + ']' : token;
+    }).join(dots ? '.' : '');
+}
+function isFlatArray(arr) {
+    return utils.isArray(arr) && !arr.some(isVisitable);
+}
+const predicates = utils.toFlatObject(utils, {}, null, function(prop) {
+    return /^is[A-Z]/.test(prop);
+});
+function toFormData_toFormData(obj, formData, options) {
+    if (!utils.isObject(obj)) throw new TypeError('target must be an object');
+    formData = formData || new (helpers_null || FormData)();
+    options = utils.toFlatObject(options, {
+        metaTokens: true,
+        dots: false,
+        indexes: false
+    }, false, function(option, source) {
+        return !utils.isUndefined(source[option]);
+    });
+    const metaTokens = options.metaTokens;
+    const visitor = options.visitor || defaultVisitor;
+    const dots = options.dots;
+    const indexes = options.indexes;
+    const _Blob = options.Blob || 'undefined' != typeof Blob && Blob;
+    const useBlob = _Blob && utils.isSpecCompliantForm(formData);
+    if (!utils.isFunction(visitor)) throw new TypeError('visitor must be a function');
+    function convertValue(value) {
+        if (null === value) return '';
+        if (utils.isDate(value)) return value.toISOString();
+        if (!useBlob && utils.isBlob(value)) throw new core_AxiosError('Blob is not supported. Use a Buffer instead.');
+        if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) return useBlob && 'function' == typeof Blob ? new Blob([
+            value
+        ]) : Buffer.from(value);
+        return value;
+    }
+    function defaultVisitor(value, key, path) {
+        let arr = value;
+        if (value && !path && 'object' == typeof value) {
+            if (utils.endsWith(key, '{}')) {
+                key = metaTokens ? key : key.slice(0, -2);
+                value = JSON.stringify(value);
+            } else if (utils.isArray(value) && isFlatArray(value) || (utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))) {
+                key = removeBrackets(key);
+                arr.forEach(function(el, index) {
+                    utils.isUndefined(el) || null === el || formData.append(true === indexes ? renderKey([
+                        key
+                    ], index, dots) : null === indexes ? key : key + '[]', convertValue(el));
+                });
+                return false;
+            }
+        }
+        if (isVisitable(value)) return true;
+        formData.append(renderKey(path, key, dots), convertValue(value));
+        return false;
+    }
+    const stack = [];
+    const exposedHelpers = Object.assign(predicates, {
+        defaultVisitor,
+        convertValue,
+        isVisitable
+    });
+    function build(value, path) {
+        if (utils.isUndefined(value)) return;
+        if (-1 !== stack.indexOf(value)) throw Error('Circular reference detected in ' + path.join('.'));
+        stack.push(value);
+        utils.forEach(value, function(el, key) {
+            const result = !(utils.isUndefined(el) || null === el) && visitor.call(formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers);
+            if (true === result) build(el, path ? path.concat(key) : [
+                key
+            ]);
+        });
+        stack.pop();
+    }
+    if (!utils.isObject(obj)) throw new TypeError('data must be an object');
+    build(obj);
+    return formData;
+}
+const toFormData = toFormData_toFormData;
+function encode(str) {
+    const charMap = {
+        '!': '%21',
+        "'": '%27',
+        '(': '%28',
+        ')': '%29',
+        '~': '%7E',
+        '%20': '+',
+        '%00': '\x00'
+    };
+    return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function(match) {
+        return charMap[match];
+    });
+}
+function AxiosURLSearchParams_AxiosURLSearchParams(params, options) {
+    this._pairs = [];
+    params && toFormData(params, this, options);
+}
+const AxiosURLSearchParams_prototype = AxiosURLSearchParams_AxiosURLSearchParams.prototype;
+AxiosURLSearchParams_prototype.append = function(name, value) {
+    this._pairs.push([
+        name,
+        value
+    ]);
+};
+AxiosURLSearchParams_prototype.toString = function(encoder) {
+    const _encode = encoder ? function(value) {
+        return encoder.call(this, value, encode);
+    } : encode;
+    return this._pairs.map(function(pair) {
+        return _encode(pair[0]) + '=' + _encode(pair[1]);
+    }, '').join('&');
+};
+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, ']');
+}
+function buildURL(url, params, options) {
+    if (!params) return url;
+    const _encode = options && options.encode || buildURL_encode;
+    if (utils.isFunction(options)) options = {
+        serialize: options
+    };
+    const serializeFn = options && options.serialize;
+    let serializedParams;
+    serializedParams = serializeFn ? serializeFn(params, options) : utils.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, options).toString(_encode);
+    if (serializedParams) {
+        const hashmarkIndex = url.indexOf("#");
+        if (-1 !== hashmarkIndex) url = url.slice(0, hashmarkIndex);
+        url += (-1 === url.indexOf('?') ? '?' : '&') + serializedParams;
+    }
+    return url;
+}
+class InterceptorManager {
+    constructor(){
+        this.handlers = [];
+    }
+    use(fulfilled, rejected, options) {
+        this.handlers.push({
+            fulfilled,
+            rejected,
+            synchronous: options ? options.synchronous : false,
+            runWhen: options ? options.runWhen : null
+        });
+        return this.handlers.length - 1;
+    }
+    eject(id) {
+        if (this.handlers[id]) this.handlers[id] = null;
+    }
+    clear() {
+        if (this.handlers) this.handlers = [];
+    }
+    forEach(fn) {
+        utils.forEach(this.handlers, function(h) {
+            if (null !== h) fn(h);
+        });
+    }
+}
+const core_InterceptorManager = InterceptorManager;
+const defaults_transitional = {
+    silentJSONParsing: true,
+    forcedJSONParsing: true,
+    clarifyTimeoutError: false
+};
+const classes_URLSearchParams = 'undefined' != typeof URLSearchParams ? URLSearchParams : AxiosURLSearchParams;
+const classes_FormData = 'undefined' != typeof FormData ? FormData : null;
+const classes_Blob = 'undefined' != typeof Blob ? Blob : null;
+const browser = {
+    isBrowser: true,
+    classes: {
+        URLSearchParams: classes_URLSearchParams,
+        FormData: classes_FormData,
+        Blob: classes_Blob
+    },
+    protocols: [
+        'http',
+        'https',
+        'file',
+        'blob',
+        'url',
+        'data'
+    ]
+};
+const hasBrowserEnv = 'undefined' != typeof window && 'undefined' != typeof document;
+const _navigator = 'object' == typeof navigator && navigator || void 0;
+const hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || [
+    'ReactNative',
+    'NativeScript',
+    'NS'
+].indexOf(_navigator.product) < 0);
+const hasStandardBrowserWebWorkerEnv = (()=>'undefined' != typeof WorkerGlobalScope && self instanceof WorkerGlobalScope && 'function' == typeof self.importScripts)();
+const utils_origin = hasBrowserEnv && window.location.href || 'http://localhost';
+const platform = {
+    ...common_utils_namespaceObject,
+    ...browser
+};
+function toURLEncodedForm(data, options) {
+    return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
+        visitor: function(value, key, path, helpers) {
+            if (platform.isNode && utils.isBuffer(value)) {
+                this.append(key, value.toString('base64'));
+                return false;
+            }
+            return helpers.defaultVisitor.apply(this, arguments);
+        }
+    }, options));
+}
+function parsePropPath(name) {
+    return utils.matchAll(/\w+|\[(\w*)]/g, name).map((match)=>'[]' === match[0] ? '' : match[1] || match[0]);
+}
+function arrayToObject(arr) {
+    const obj = {};
+    const keys = Object.keys(arr);
+    let i;
+    const len = keys.length;
+    let key;
+    for(i = 0; i < len; i++){
+        key = keys[i];
+        obj[key] = arr[key];
+    }
+    return obj;
+}
+function formDataToJSON_formDataToJSON(formData) {
+    function buildPath(path, value, target, index) {
+        let name = path[index++];
+        if ('__proto__' === name) return true;
+        const isNumericKey = Number.isFinite(+name);
+        const isLast = index >= path.length;
+        name = !name && utils.isArray(target) ? target.length : name;
+        if (isLast) {
+            if (utils.hasOwnProp(target, name)) target[name] = [
+                target[name],
+                value
+            ];
+            else target[name] = value;
+            return !isNumericKey;
+        }
+        if (!target[name] || !utils.isObject(target[name])) target[name] = [];
+        const result = buildPath(path, value, target[name], index);
+        if (result && utils.isArray(target[name])) target[name] = arrayToObject(target[name]);
+        return !isNumericKey;
+    }
+    if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
+        const obj = {};
+        utils.forEachEntry(formData, (name, value)=>{
+            buildPath(parsePropPath(name), value, obj, 0);
+        });
+        return obj;
+    }
+    return null;
+}
+const formDataToJSON = formDataToJSON_formDataToJSON;
+function stringifySafely(rawValue, parser, encoder) {
+    if (utils.isString(rawValue)) try {
+        (parser || JSON.parse)(rawValue);
+        return utils.trim(rawValue);
+    } catch (e) {
+        if ('SyntaxError' !== e.name) throw e;
+    }
+    return (encoder || JSON.stringify)(rawValue);
+}
+const defaults = {
+    transitional: defaults_transitional,
+    adapter: [
+        'xhr',
+        'http',
+        'fetch'
+    ],
+    transformRequest: [
+        function(data, headers) {
+            const contentType = headers.getContentType() || '';
+            const hasJSONContentType = contentType.indexOf('application/json') > -1;
+            const isObjectPayload = utils.isObject(data);
+            if (isObjectPayload && utils.isHTMLForm(data)) data = new FormData(data);
+            const isFormData = utils.isFormData(data);
+            if (isFormData) return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
+            if (utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data) || utils.isReadableStream(data)) return data;
+            if (utils.isArrayBufferView(data)) return data.buffer;
+            if (utils.isURLSearchParams(data)) {
+                headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
+                return data.toString();
+            }
+            let isFileList;
+            if (isObjectPayload) {
+                if (contentType.indexOf('application/x-www-form-urlencoded') > -1) return toURLEncodedForm(data, this.formSerializer).toString();
+                if ((isFileList = utils.isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
+                    const _FormData = this.env && this.env.FormData;
+                    return toFormData(isFileList ? {
+                        'files[]': data
+                    } : data, _FormData && new _FormData(), this.formSerializer);
+                }
+            }
+            if (isObjectPayload || hasJSONContentType) {
+                headers.setContentType('application/json', false);
+                return stringifySafely(data);
+            }
+            return data;
+        }
+    ],
+    transformResponse: [
+        function(data) {
+            const transitional = this.transitional || defaults.transitional;
+            const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+            const JSONRequested = 'json' === this.responseType;
+            if (utils.isResponse(data) || utils.isReadableStream(data)) return data;
+            if (data && utils.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
+                const silentJSONParsing = transitional && transitional.silentJSONParsing;
+                const strictJSONParsing = !silentJSONParsing && JSONRequested;
+                try {
+                    return JSON.parse(data);
+                } catch (e) {
+                    if (strictJSONParsing) {
+                        if ('SyntaxError' === e.name) throw core_AxiosError.from(e, core_AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
+                        throw e;
+                    }
+                }
+            }
+            return data;
+        }
+    ],
+    timeout: 0,
+    xsrfCookieName: 'XSRF-TOKEN',
+    xsrfHeaderName: 'X-XSRF-TOKEN',
+    maxContentLength: -1,
+    maxBodyLength: -1,
+    env: {
+        FormData: platform.classes.FormData,
+        Blob: platform.classes.Blob
+    },
+    validateStatus: function(status) {
+        return status >= 200 && status < 300;
+    },
+    headers: {
+        common: {
+            Accept: 'application/json, text/plain, */*',
+            'Content-Type': void 0
+        }
+    }
+};
+utils.forEach([
+    'delete',
+    'get',
+    'head',
+    'post',
+    'put',
+    'patch'
+], (method)=>{
+    defaults.headers[method] = {};
+});
+const lib_defaults = defaults;
+const ignoreDuplicateOf = utils.toObjectSet([
+    'age',
+    'authorization',
+    'content-length',
+    'content-type',
+    'etag',
+    'expires',
+    'from',
+    'host',
+    'if-modified-since',
+    'if-unmodified-since',
+    'last-modified',
+    'location',
+    'max-forwards',
+    'proxy-authorization',
+    'referer',
+    'retry-after',
+    'user-agent'
+]);
+const parseHeaders = (rawHeaders)=>{
+    const parsed = {};
+    let key;
+    let val;
+    let i;
+    rawHeaders && rawHeaders.split('\n').forEach(function(line) {
+        i = line.indexOf(':');
+        key = line.substring(0, i).trim().toLowerCase();
+        val = line.substring(i + 1).trim();
+        if (!key || parsed[key] && ignoreDuplicateOf[key]) return;
+        if ('set-cookie' === key) if (parsed[key]) parsed[key].push(val);
+        else parsed[key] = [
+            val
+        ];
+        else parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
+    });
+    return parsed;
+};
+const $internals = Symbol('internals');
+function normalizeHeader(header) {
+    return header && String(header).trim().toLowerCase();
+}
+function normalizeValue(value) {
+    if (false === value || null == value) return value;
+    return utils.isArray(value) ? value.map(normalizeValue) : String(value);
+}
+function parseTokens(str) {
+    const tokens = Object.create(null);
+    const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+    let match;
+    while(match = tokensRE.exec(str))tokens[match[1]] = match[2];
+    return tokens;
+}
+const isValidHeaderName = (str)=>/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
+function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
+    if (utils.isFunction(filter)) return filter.call(this, value, header);
+    if (isHeaderNameFilter) value = header;
+    if (!utils.isString(value)) return;
+    if (utils.isString(filter)) return -1 !== value.indexOf(filter);
+    if (utils.isRegExp(filter)) return filter.test(value);
+}
+function formatHeader(header) {
+    return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str)=>char.toUpperCase() + str);
+}
+function buildAccessors(obj, header) {
+    const accessorName = utils.toCamelCase(' ' + header);
+    [
+        'get',
+        'set',
+        'has'
+    ].forEach((methodName)=>{
+        Object.defineProperty(obj, methodName + accessorName, {
+            value: function(arg1, arg2, arg3) {
+                return this[methodName].call(this, header, arg1, arg2, arg3);
+            },
+            configurable: true
+        });
+    });
+}
+class AxiosHeaders {
+    constructor(headers){
+        headers && this.set(headers);
+    }
+    set(header, valueOrRewrite, rewrite) {
+        const self1 = this;
+        function setHeader(_value, _header, _rewrite) {
+            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);
+        }
+        const setHeaders = (headers, _rewrite)=>utils.forEach(headers, (_value, _header)=>setHeader(_value, _header, _rewrite));
+        if (utils.isPlainObject(header) || header instanceof this.constructor) setHeaders(header, valueOrRewrite);
+        else if (utils.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) setHeaders(parseHeaders(header), valueOrRewrite);
+        else if (utils.isObject(header) && utils.isIterable(header)) {
+            let obj = {}, dest, key;
+            for (const entry of header){
+                if (!utils.isArray(entry)) throw TypeError('Object iterator must return a key-value pair');
+                obj[key = entry[0]] = (dest = obj[key]) ? utils.isArray(dest) ? [
+                    ...dest,
+                    entry[1]
+                ] : [
+                    dest,
+                    entry[1]
+                ] : entry[1];
+            }
+            setHeaders(obj, valueOrRewrite);
+        } else null != header && setHeader(valueOrRewrite, header, rewrite);
+        return this;
+    }
+    get(header, parser) {
+        header = normalizeHeader(header);
+        if (header) {
+            const key = utils.findKey(this, header);
+            if (key) {
+                const value = this[key];
+                if (!parser) return value;
+                if (true === parser) return parseTokens(value);
+                if (utils.isFunction(parser)) return parser.call(this, value, key);
+                if (utils.isRegExp(parser)) return parser.exec(value);
+                throw new TypeError('parser must be boolean|regexp|function');
+            }
+        }
+    }
+    has(header, matcher) {
+        header = normalizeHeader(header);
+        if (header) {
+            const key = utils.findKey(this, header);
+            return !!(key && void 0 !== this[key] && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+        }
+        return false;
+    }
+    delete(header, matcher) {
+        const self1 = this;
+        let deleted = false;
+        function deleteHeader(_header) {
+            _header = normalizeHeader(_header);
+            if (_header) {
+                const key = utils.findKey(self1, _header);
+                if (key && (!matcher || matchHeaderValue(self1, self1[key], key, matcher))) {
+                    delete self1[key];
+                    deleted = true;
+                }
+            }
+        }
+        if (utils.isArray(header)) header.forEach(deleteHeader);
+        else deleteHeader(header);
+        return deleted;
+    }
+    clear(matcher) {
+        const keys = Object.keys(this);
+        let i = keys.length;
+        let deleted = false;
+        while(i--){
+            const key = keys[i];
+            if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+                delete this[key];
+                deleted = true;
+            }
+        }
+        return deleted;
+    }
+    normalize(format) {
+        const self1 = this;
+        const headers = {};
+        utils.forEach(this, (value, header)=>{
+            const key = utils.findKey(headers, header);
+            if (key) {
+                self1[key] = normalizeValue(value);
+                delete self1[header];
+                return;
+            }
+            const normalized = format ? formatHeader(header) : String(header).trim();
+            if (normalized !== header) delete self1[header];
+            self1[normalized] = normalizeValue(value);
+            headers[normalized] = true;
+        });
+        return this;
+    }
+    concat(...targets) {
+        return this.constructor.concat(this, ...targets);
+    }
+    toJSON(asStrings) {
+        const obj = Object.create(null);
+        utils.forEach(this, (value, header)=>{
+            null != value && false !== value && (obj[header] = asStrings && utils.isArray(value) ? value.join(', ') : value);
+        });
+        return obj;
+    }
+    [Symbol.iterator]() {
+        return Object.entries(this.toJSON())[Symbol.iterator]();
+    }
+    toString() {
+        return Object.entries(this.toJSON()).map(([header, value])=>header + ': ' + value).join('\n');
+    }
+    getSetCookie() {
+        return this.get("set-cookie") || [];
+    }
+    get [Symbol.toStringTag]() {
+        return 'AxiosHeaders';
+    }
+    static from(thing) {
+        return thing instanceof this ? thing : new this(thing);
+    }
+    static concat(first, ...targets) {
+        const computed = new this(first);
+        targets.forEach((target)=>computed.set(target));
+        return computed;
+    }
+    static accessor(header) {
+        const internals = this[$internals] = this[$internals] = {
+            accessors: {}
+        };
+        const accessors = internals.accessors;
+        const prototype = this.prototype;
+        function defineAccessor(_header) {
+            const lHeader = normalizeHeader(_header);
+            if (!accessors[lHeader]) {
+                buildAccessors(prototype, _header);
+                accessors[lHeader] = true;
+            }
+        }
+        utils.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
+        return this;
+    }
+}
+AxiosHeaders.accessor([
+    'Content-Type',
+    'Content-Length',
+    'Accept',
+    'Accept-Encoding',
+    'User-Agent',
+    'Authorization'
+]);
+utils.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key)=>{
+    let mapped = key[0].toUpperCase() + key.slice(1);
+    return {
+        get: ()=>value,
+        set (headerValue) {
+            this[mapped] = headerValue;
+        }
+    };
+});
+utils.freezeMethods(AxiosHeaders);
+const core_AxiosHeaders = AxiosHeaders;
+function transformData(fns, response) {
+    const config = this || lib_defaults;
+    const context = response || config;
+    const headers = core_AxiosHeaders.from(context.headers);
+    let data = context.data;
+    utils.forEach(fns, function(fn) {
+        data = fn.call(config, data, headers.normalize(), response ? response.status : void 0);
+    });
+    headers.normalize();
+    return data;
+}
+function isCancel(value) {
+    return !!(value && value.__CANCEL__);
+}
+function CanceledError_CanceledError(message, config, request) {
+    core_AxiosError.call(this, null == message ? 'canceled' : message, core_AxiosError.ERR_CANCELED, config, request);
+    this.name = 'CanceledError';
+}
+utils.inherits(CanceledError_CanceledError, core_AxiosError, {
+    __CANCEL__: true
+});
+const CanceledError = CanceledError_CanceledError;
+function settle(resolve, reject, response) {
+    const validateStatus = response.config.validateStatus;
+    if (!response.status || !validateStatus || validateStatus(response.status)) resolve(response);
+    else reject(new core_AxiosError('Request failed with status code ' + response.status, [
+        core_AxiosError.ERR_BAD_REQUEST,
+        core_AxiosError.ERR_BAD_RESPONSE
+    ][Math.floor(response.status / 100) - 4], response.config, response.request, response));
+}
+function parseProtocol(url) {
+    const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+    return match && match[1] || '';
+}
+function speedometer(samplesCount, min) {
+    samplesCount = samplesCount || 10;
+    const bytes = new Array(samplesCount);
+    const timestamps = new Array(samplesCount);
+    let head = 0;
+    let tail = 0;
+    let firstSampleTS;
+    min = void 0 !== min ? min : 1000;
+    return function(chunkLength) {
+        const now = Date.now();
+        const startedAt = timestamps[tail];
+        if (!firstSampleTS) firstSampleTS = now;
+        bytes[head] = chunkLength;
+        timestamps[head] = now;
+        let i = tail;
+        let bytesCount = 0;
+        while(i !== head){
+            bytesCount += bytes[i++];
+            i %= samplesCount;
+        }
+        head = (head + 1) % samplesCount;
+        if (head === tail) tail = (tail + 1) % samplesCount;
+        if (now - firstSampleTS < min) return;
+        const passed = startedAt && now - startedAt;
+        return passed ? Math.round(1000 * bytesCount / passed) : void 0;
+    };
+}
+const helpers_speedometer = speedometer;
+function throttle(fn, freq) {
+    let timestamp = 0;
+    let threshold = 1000 / freq;
+    let lastArgs;
+    let timer;
+    const invoke = (args, now = Date.now())=>{
+        timestamp = now;
+        lastArgs = null;
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        fn.apply(null, args);
+    };
+    const throttled = (...args)=>{
+        const now = Date.now();
+        const passed = now - timestamp;
+        if (passed >= threshold) invoke(args, now);
+        else {
+            lastArgs = args;
+            if (!timer) timer = setTimeout(()=>{
+                timer = null;
+                invoke(lastArgs);
+            }, threshold - passed);
+        }
+    };
+    const flush = ()=>lastArgs && invoke(lastArgs);
+    return [
+        throttled,
+        flush
+    ];
+}
+const helpers_throttle = throttle;
+const progressEventReducer = (listener, isDownloadStream, freq = 3)=>{
+    let bytesNotified = 0;
+    const _speedometer = helpers_speedometer(50, 250);
+    return helpers_throttle((e)=>{
+        const loaded = e.loaded;
+        const total = e.lengthComputable ? e.total : void 0;
+        const progressBytes = loaded - bytesNotified;
+        const rate = _speedometer(progressBytes);
+        const inRange = loaded <= total;
+        bytesNotified = loaded;
+        const data = {
+            loaded,
+            total,
+            progress: total ? loaded / total : void 0,
+            bytes: progressBytes,
+            rate: rate ? rate : void 0,
+            estimated: rate && total && inRange ? (total - loaded) / rate : void 0,
+            event: e,
+            lengthComputable: null != total,
+            [isDownloadStream ? 'download' : 'upload']: true
+        };
+        listener(data);
+    }, freq);
+};
+const progressEventDecorator = (total, throttled)=>{
+    const lengthComputable = null != total;
+    return [
+        (loaded)=>throttled[0]({
+                lengthComputable,
+                total,
+                loaded
+            }),
+        throttled[1]
+    ];
+};
+const asyncDecorator = (fn)=>(...args)=>utils.asap(()=>fn(...args));
+const isURLSameOrigin = platform.hasStandardBrowserEnv ? ((origin, isMSIE)=>(url)=>{
+        url = new URL(url, platform.origin);
+        return origin.protocol === url.protocol && origin.host === url.host && (isMSIE || origin.port === url.port);
+    })(new URL(platform.origin), platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)) : ()=>true;
+const cookies = platform.hasStandardBrowserEnv ? {
+    write (name, value, expires, path, domain, secure) {
+        const cookie = [
+            name + '=' + encodeURIComponent(value)
+        ];
+        utils.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());
+        utils.isString(path) && cookie.push('path=' + path);
+        utils.isString(domain) && cookie.push('domain=' + domain);
+        true === secure && cookie.push('secure');
+        document.cookie = cookie.join('; ');
+    },
+    read (name) {
+        const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+        return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove (name) {
+        this.write(name, '', Date.now() - 86400000);
+    }
+} : {
+    write () {},
+    read () {
+        return null;
+    },
+    remove () {}
+};
+function isAbsoluteURL(url) {
+    return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}
+function combineURLs(baseURL, relativeURL) {
+    return relativeURL ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '') : baseURL;
+}
+function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+    let isRelativeUrl = !isAbsoluteURL(requestedURL);
+    if (baseURL && (isRelativeUrl || false == allowAbsoluteUrls)) return combineURLs(baseURL, requestedURL);
+    return requestedURL;
+}
+const headersToObject = (thing)=>thing instanceof core_AxiosHeaders ? {
+        ...thing
+    } : thing;
+function mergeConfig(config1, config2) {
+    config2 = config2 || {};
+    const config = {};
+    function getMergedValue(target, source, prop, caseless) {
+        if (utils.isPlainObject(target) && utils.isPlainObject(source)) return utils.merge.call({
+            caseless
+        }, target, source);
+        if (utils.isPlainObject(source)) return utils.merge({}, source);
+        if (utils.isArray(source)) return source.slice();
+        return source;
+    }
+    function mergeDeepProperties(a, b, prop, caseless) {
+        if (!utils.isUndefined(b)) return getMergedValue(a, b, prop, caseless);
+        if (!utils.isUndefined(a)) return getMergedValue(void 0, a, prop, caseless);
+    }
+    function valueFromConfig2(a, b) {
+        if (!utils.isUndefined(b)) return getMergedValue(void 0, b);
+    }
+    function defaultToConfig2(a, b) {
+        if (!utils.isUndefined(b)) return getMergedValue(void 0, b);
+        if (!utils.isUndefined(a)) return getMergedValue(void 0, a);
+    }
+    function mergeDirectKeys(a, b, prop) {
+        if (prop in config2) return getMergedValue(a, b);
+        if (prop in config1) return getMergedValue(void 0, a);
+    }
+    const mergeMap = {
+        url: valueFromConfig2,
+        method: valueFromConfig2,
+        data: valueFromConfig2,
+        baseURL: defaultToConfig2,
+        transformRequest: defaultToConfig2,
+        transformResponse: defaultToConfig2,
+        paramsSerializer: defaultToConfig2,
+        timeout: defaultToConfig2,
+        timeoutMessage: defaultToConfig2,
+        withCredentials: defaultToConfig2,
+        withXSRFToken: defaultToConfig2,
+        adapter: defaultToConfig2,
+        responseType: defaultToConfig2,
+        xsrfCookieName: defaultToConfig2,
+        xsrfHeaderName: defaultToConfig2,
+        onUploadProgress: defaultToConfig2,
+        onDownloadProgress: defaultToConfig2,
+        decompress: defaultToConfig2,
+        maxContentLength: defaultToConfig2,
+        maxBodyLength: defaultToConfig2,
+        beforeRedirect: defaultToConfig2,
+        transport: defaultToConfig2,
+        httpAgent: defaultToConfig2,
+        httpsAgent: defaultToConfig2,
+        cancelToken: defaultToConfig2,
+        socketPath: defaultToConfig2,
+        responseEncoding: defaultToConfig2,
+        validateStatus: mergeDirectKeys,
+        headers: (a, b, prop)=>mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
+    };
+    utils.forEach(Object.keys(Object.assign({}, config1, config2)), function(prop) {
+        const merge = mergeMap[prop] || mergeDeepProperties;
+        const configValue = merge(config1[prop], config2[prop], prop);
+        utils.isUndefined(configValue) && merge !== mergeDirectKeys || (config[prop] = configValue);
+    });
+    return config;
+}
+const resolveConfig = (config)=>{
+    const newConfig = mergeConfig({}, config);
+    let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
+    newConfig.headers = headers = core_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('; '));
+        }
+    }
+    if (platform.hasStandardBrowserEnv) {
+        withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
+        if (withXSRFToken || false !== withXSRFToken && isURLSameOrigin(newConfig.url)) {
+            const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);
+            if (xsrfValue) headers.set(xsrfHeaderName, xsrfValue);
+        }
+    }
+    return newConfig;
+};
+const isXHRAdapterSupported = 'undefined' != typeof XMLHttpRequest;
+const xhr = isXHRAdapterSupported && function(config) {
+    return new Promise(function(resolve, reject) {
+        const _config = resolveConfig(config);
+        let requestData = _config.data;
+        const requestHeaders = core_AxiosHeaders.from(_config.headers).normalize();
+        let { responseType, onUploadProgress, onDownloadProgress } = _config;
+        let onCanceled;
+        let uploadThrottled, downloadThrottled;
+        let flushUpload, flushDownload;
+        function done() {
+            flushUpload && flushUpload();
+            flushDownload && flushDownload();
+            _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
+            _config.signal && _config.signal.removeEventListener('abort', onCanceled);
+        }
+        let request = new XMLHttpRequest();
+        request.open(_config.method.toUpperCase(), _config.url, true);
+        request.timeout = _config.timeout;
+        function onloadend() {
+            if (!request) return;
+            const responseHeaders = core_AxiosHeaders.from('getAllResponseHeaders' in request && request.getAllResponseHeaders());
+            const responseData = responseType && 'text' !== responseType && 'json' !== responseType ? request.response : request.responseText;
+            const response = {
+                data: responseData,
+                status: request.status,
+                statusText: request.statusText,
+                headers: responseHeaders,
+                config,
+                request
+            };
+            settle(function(value) {
+                resolve(value);
+                done();
+            }, function(err) {
+                reject(err);
+                done();
+            }, response);
+            request = null;
+        }
+        if ('onloadend' in request) request.onloadend = onloadend;
+        else request.onreadystatechange = function() {
+            if (!request || 4 !== request.readyState) return;
+            if (0 === request.status && !(request.responseURL && 0 === request.responseURL.indexOf('file:'))) return;
+            setTimeout(onloadend);
+        };
+        request.onabort = function() {
+            if (!request) return;
+            reject(new core_AxiosError('Request aborted', core_AxiosError.ECONNABORTED, config, request));
+            request = null;
+        };
+        request.onerror = function() {
+            reject(new core_AxiosError('Network Error', core_AxiosError.ERR_NETWORK, config, request));
+            request = null;
+        };
+        request.ontimeout = function() {
+            let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';
+            const transitional = _config.transitional || defaults_transitional;
+            if (_config.timeoutErrorMessage) timeoutErrorMessage = _config.timeoutErrorMessage;
+            reject(new core_AxiosError(timeoutErrorMessage, transitional.clarifyTimeoutError ? core_AxiosError.ETIMEDOUT : core_AxiosError.ECONNABORTED, config, request));
+            request = null;
+        };
+        void 0 === requestData && requestHeaders.setContentType(null);
+        if ('setRequestHeader' in request) utils.forEach(requestHeaders.toJSON(), function(val, key) {
+            request.setRequestHeader(key, val);
+        });
+        if (!utils.isUndefined(_config.withCredentials)) request.withCredentials = !!_config.withCredentials;
+        if (responseType && 'json' !== responseType) request.responseType = _config.responseType;
+        if (onDownloadProgress) {
+            [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
+            request.addEventListener('progress', downloadThrottled);
+        }
+        if (onUploadProgress && request.upload) {
+            [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
+            request.upload.addEventListener('progress', uploadThrottled);
+            request.upload.addEventListener('loadend', flushUpload);
+        }
+        if (_config.cancelToken || _config.signal) {
+            onCanceled = (cancel)=>{
+                if (!request) return;
+                reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
+                request.abort();
+                request = null;
+            };
+            _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
+            if (_config.signal) _config.signal.aborted ? onCanceled() : _config.signal.addEventListener('abort', onCanceled);
+        }
+        const protocol = parseProtocol(_config.url);
+        if (protocol && -1 === platform.protocols.indexOf(protocol)) return void reject(new core_AxiosError('Unsupported protocol ' + protocol + ':', core_AxiosError.ERR_BAD_REQUEST, config));
+        request.send(requestData || null);
+    });
+};
+const composeSignals_composeSignals = (signals, timeout)=>{
+    const { length } = signals = signals ? signals.filter(Boolean) : [];
+    if (timeout || length) {
+        let controller = new AbortController();
+        let aborted;
+        const onabort = function(reason) {
+            if (!aborted) {
+                aborted = true;
+                unsubscribe();
+                const err = reason instanceof Error ? reason : this.reason;
+                controller.abort(err instanceof core_AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
+            }
+        };
+        let timer = timeout && setTimeout(()=>{
+            timer = null;
+            onabort(new core_AxiosError(`timeout ${timeout} of ms exceeded`, core_AxiosError.ETIMEDOUT));
+        }, timeout);
+        const unsubscribe = ()=>{
+            if (signals) {
+                timer && clearTimeout(timer);
+                timer = null;
+                signals.forEach((signal)=>{
+                    signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);
+                });
+                signals = null;
+            }
+        };
+        signals.forEach((signal)=>signal.addEventListener('abort', onabort));
+        const { signal } = controller;
+        signal.unsubscribe = ()=>utils.asap(unsubscribe);
+        return signal;
+    }
+};
+const composeSignals = composeSignals_composeSignals;
+const streamChunk = function*(chunk, chunkSize) {
+    let len = chunk.byteLength;
+    if (!chunkSize || len < chunkSize) return void (yield chunk);
+    let pos = 0;
+    let end;
+    while(pos < len){
+        end = pos + chunkSize;
+        yield chunk.slice(pos, end);
+        pos = end;
+    }
+};
+const readBytes = async function*(iterable, chunkSize) {
+    for await (const chunk of readStream(iterable))yield* streamChunk(chunk, chunkSize);
+};
+const readStream = async function*(stream) {
+    if (stream[Symbol.asyncIterator]) return void (yield* stream);
+    const reader = stream.getReader();
+    try {
+        for(;;){
+            const { done, value } = await reader.read();
+            if (done) break;
+            yield value;
+        }
+    } finally{
+        await reader.cancel();
+    }
+};
+const trackStream = (stream, chunkSize, onProgress, onFinish)=>{
+    const iterator = readBytes(stream, chunkSize);
+    let bytes = 0;
+    let done;
+    let _onFinish = (e)=>{
+        if (!done) {
+            done = true;
+            onFinish && onFinish(e);
+        }
+    };
+    return new ReadableStream({
+        async pull (controller) {
+            try {
+                const { done, value } = await iterator.next();
+                if (done) {
+                    _onFinish();
+                    controller.close();
+                    return;
+                }
+                let len = value.byteLength;
+                if (onProgress) {
+                    let loadedBytes = bytes += len;
+                    onProgress(loadedBytes);
+                }
+                controller.enqueue(new Uint8Array(value));
+            } catch (err) {
+                _onFinish(err);
+                throw err;
+            }
+        },
+        cancel (reason) {
+            _onFinish(reason);
+            return iterator.return();
+        }
+    }, {
+        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 test = (fn, ...args)=>{
+    try {
+        return !!fn(...args);
+    } catch (e) {
+        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 core_AxiosError(`Response type '${type}' is not supported`, core_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, {
+            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 = composeSignals([
+        signal,
+        cancelToken && cancelToken.toAbortSignal()
+    ], timeout);
+    let request;
+    const unsubscribe = composedSignal && composedSignal.unsubscribe && (()=>{
+        composedSignal.unsubscribe();
+    });
+    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 = "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
+        });
+        let response = await fetch(request);
+        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: core_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 core_AxiosError('Network Error', core_AxiosError.ERR_NETWORK, config, request), {
+            cause: err.cause || err
+        });
+        throw core_AxiosError.from(err, err && err.code, config, request);
+    }
+});
+const knownAdapters = {
+    http: helpers_null,
+    xhr: xhr,
+    fetch: adapters_fetch
+};
+utils.forEach(knownAdapters, (fn, value)=>{
+    if (fn) {
+        try {
+            Object.defineProperty(fn, 'name', {
+                value
+            });
+        } catch (e) {}
+        Object.defineProperty(fn, 'adapterName', {
+            value
+        });
+    }
+});
+const renderReason = (reason)=>`- ${reason}`;
+const isResolvedHandle = (adapter)=>utils.isFunction(adapter) || null === adapter || false === adapter;
+const adapters_adapters = {
+    getAdapter: (adapters)=>{
+        adapters = utils.isArray(adapters) ? adapters : [
+            adapters
+        ];
+        const { length } = adapters;
+        let nameOrAdapter;
+        let adapter;
+        const rejectedReasons = {};
+        for(let i = 0; i < length; i++){
+            nameOrAdapter = adapters[i];
+            let id;
+            adapter = nameOrAdapter;
+            if (!isResolvedHandle(nameOrAdapter)) {
+                adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+                if (void 0 === adapter) throw new core_AxiosError(`Unknown adapter '${id}'`);
+            }
+            if (adapter) break;
+            rejectedReasons[id || '#' + i] = adapter;
+        }
+        if (!adapter) {
+            const reasons = Object.entries(rejectedReasons).map(([id, state])=>`adapter ${id} ` + (false === state ? 'is not supported by the environment' : 'is not available in the build'));
+            let s = length ? reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0]) : 'as no adapter specified';
+            throw new core_AxiosError("There is no suitable adapter to dispatch the request " + s, 'ERR_NOT_SUPPORT');
+        }
+        return adapter;
+    },
+    adapters: knownAdapters
+};
+function throwIfCancellationRequested(config) {
+    if (config.cancelToken) config.cancelToken.throwIfRequested();
+    if (config.signal && config.signal.aborted) throw new CanceledError(null, config);
+}
+function dispatchRequest(config) {
+    throwIfCancellationRequested(config);
+    config.headers = core_AxiosHeaders.from(config.headers);
+    config.data = transformData.call(config, config.transformRequest);
+    if (-1 !== [
+        'post',
+        'put',
+        'patch'
+    ].indexOf(config.method)) config.headers.setContentType('application/x-www-form-urlencoded', false);
+    const adapter = adapters_adapters.getAdapter(config.adapter || lib_defaults.adapter);
+    return adapter(config).then(function(response) {
+        throwIfCancellationRequested(config);
+        response.data = transformData.call(config, config.transformResponse, response);
+        response.headers = core_AxiosHeaders.from(response.headers);
+        return response;
+    }, function(reason) {
+        if (!isCancel(reason)) {
+            throwIfCancellationRequested(config);
+            if (reason && reason.response) {
+                reason.response.data = transformData.call(config, config.transformResponse, reason.response);
+                reason.response.headers = core_AxiosHeaders.from(reason.response.headers);
+            }
+        }
+        return Promise.reject(reason);
+    });
+}
+const VERSION = "1.9.0";
+const validators = {};
+[
+    'object',
+    'boolean',
+    'number',
+    'function',
+    'string',
+    'symbol'
+].forEach((type, i)=>{
+    validators[type] = function(thing) {
+        return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
+    };
+});
+const deprecatedWarnings = {};
+validators.transitional = function(validator, version, message) {
+    function formatMessage(opt, desc) {
+        return '[Axios v' + VERSION + '] 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);
+        if (version && !deprecatedWarnings[opt]) {
+            deprecatedWarnings[opt] = true;
+            console.warn(formatMessage(opt, ' has been deprecated since v' + version + ' and will be removed in the near future'));
+        }
+        return validator ? validator(value, opt, opts) : true;
+    };
+};
+validators.spelling = function(correctSpelling) {
+    return (value, opt)=>{
+        console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
+        return true;
+    };
+};
+function assertOptions(options, schema, allowUnknown) {
+    if ('object' != typeof options) throw new core_AxiosError('options must be an object', core_AxiosError.ERR_BAD_OPTION_VALUE);
+    const keys = Object.keys(options);
+    let i = keys.length;
+    while(i-- > 0){
+        const opt = keys[i];
+        const validator = schema[opt];
+        if (validator) {
+            const value = options[opt];
+            const result = void 0 === value || validator(value, opt, options);
+            if (true !== result) throw new core_AxiosError('option ' + opt + ' must be ' + result, core_AxiosError.ERR_BAD_OPTION_VALUE);
+            continue;
+        }
+        if (true !== allowUnknown) throw new core_AxiosError('Unknown option ' + opt, core_AxiosError.ERR_BAD_OPTION);
+    }
+}
+const helpers_validator = {
+    assertOptions,
+    validators
+};
+const Axios_validators = helpers_validator.validators;
+class Axios_Axios {
+    constructor(instanceConfig){
+        this.defaults = instanceConfig || {};
+        this.interceptors = {
+            request: new core_InterceptorManager(),
+            response: new core_InterceptorManager()
+        };
+    }
+    async request(configOrUrl, config) {
+        try {
+            return await this._request(configOrUrl, config);
+        } catch (err) {
+            if (err instanceof Error) {
+                let dummy = {};
+                Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error();
+                const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : '';
+                try {
+                    if (err.stack) {
+                        if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ''))) err.stack += '\n' + stack;
+                    } else err.stack = stack;
+                } catch (e) {}
+            }
+            throw err;
+        }
+    }
+    _request(configOrUrl, config) {
+        if ('string' == typeof configOrUrl) {
+            config = config || {};
+            config.url = configOrUrl;
+        } else config = configOrUrl || {};
+        config = mergeConfig(this.defaults, config);
+        const { transitional, paramsSerializer, headers } = config;
+        if (void 0 !== transitional) helpers_validator.assertOptions(transitional, {
+            silentJSONParsing: Axios_validators.transitional(Axios_validators.boolean),
+            forcedJSONParsing: Axios_validators.transitional(Axios_validators.boolean),
+            clarifyTimeoutError: Axios_validators.transitional(Axios_validators.boolean)
+        }, false);
+        if (null != paramsSerializer) if (utils.isFunction(paramsSerializer)) config.paramsSerializer = {
+            serialize: paramsSerializer
+        };
+        else helpers_validator.assertOptions(paramsSerializer, {
+            encode: Axios_validators.function,
+            serialize: Axios_validators.function
+        }, true);
+        if (void 0 !== config.allowAbsoluteUrls) ;
+        else if (void 0 !== this.defaults.allowAbsoluteUrls) config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
+        else config.allowAbsoluteUrls = true;
+        helpers_validator.assertOptions(config, {
+            baseUrl: Axios_validators.spelling('baseURL'),
+            withXsrfToken: Axios_validators.spelling('withXSRFToken')
+        }, true);
+        config.method = (config.method || this.defaults.method || 'get').toLowerCase();
+        let contextHeaders = headers && utils.merge(headers.common, headers[config.method]);
+        headers && utils.forEach([
+            'delete',
+            'get',
+            'head',
+            'post',
+            'put',
+            'patch',
+            'common'
+        ], (method)=>{
+            delete headers[method];
+        });
+        config.headers = core_AxiosHeaders.concat(contextHeaders, headers);
+        const requestInterceptorChain = [];
+        let synchronousRequestInterceptors = true;
+        this.interceptors.request.forEach(function(interceptor) {
+            if ('function' == typeof interceptor.runWhen && false === interceptor.runWhen(config)) return;
+            synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+            requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+        });
+        const responseInterceptorChain = [];
+        this.interceptors.response.forEach(function(interceptor) {
+            responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+        });
+        let promise;
+        let i = 0;
+        let len;
+        if (!synchronousRequestInterceptors) {
+            const chain = [
+                dispatchRequest.bind(this),
+                void 0
+            ];
+            chain.unshift.apply(chain, requestInterceptorChain);
+            chain.push.apply(chain, responseInterceptorChain);
+            len = chain.length;
+            promise = Promise.resolve(config);
+            while(i < len)promise = promise.then(chain[i++], chain[i++]);
+            return promise;
+        }
+        len = requestInterceptorChain.length;
+        let newConfig = config;
+        i = 0;
+        while(i < len){
+            const onFulfilled = requestInterceptorChain[i++];
+            const onRejected = requestInterceptorChain[i++];
+            try {
+                newConfig = onFulfilled(newConfig);
+            } catch (error) {
+                onRejected.call(this, error);
+                break;
+            }
+        }
+        try {
+            promise = dispatchRequest.call(this, newConfig);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        i = 0;
+        len = responseInterceptorChain.length;
+        while(i < len)promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
+        return promise;
+    }
+    getUri(config) {
+        config = mergeConfig(this.defaults, config);
+        const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
+        return buildURL(fullPath, config.params, config.paramsSerializer);
+    }
+}
+utils.forEach([
+    'delete',
+    'get',
+    'head',
+    'options'
+], function(method) {
+    Axios_Axios.prototype[method] = function(url, config) {
+        return this.request(mergeConfig(config || {}, {
+            method,
+            url,
+            data: (config || {}).data
+        }));
+    };
+});
+utils.forEach([
+    'post',
+    'put',
+    'patch'
+], function(method) {
+    function generateHTTPMethod(isForm) {
+        return function(url, data, config) {
+            return this.request(mergeConfig(config || {}, {
+                method,
+                headers: isForm ? {
+                    'Content-Type': 'multipart/form-data'
+                } : {},
+                url,
+                data
+            }));
+        };
+    }
+    Axios_Axios.prototype[method] = generateHTTPMethod();
+    Axios_Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
+});
+const Axios = Axios_Axios;
+class CancelToken {
+    constructor(executor){
+        if ('function' != typeof executor) throw new TypeError('executor must be a function.');
+        let resolvePromise;
+        this.promise = new Promise(function(resolve) {
+            resolvePromise = resolve;
+        });
+        const token = this;
+        this.promise.then((cancel)=>{
+            if (!token._listeners) return;
+            let i = token._listeners.length;
+            while(i-- > 0)token._listeners[i](cancel);
+            token._listeners = null;
+        });
+        this.promise.then = (onfulfilled)=>{
+            let _resolve;
+            const promise = new Promise((resolve)=>{
+                token.subscribe(resolve);
+                _resolve = resolve;
+            }).then(onfulfilled);
+            promise.cancel = function() {
+                token.unsubscribe(_resolve);
+            };
+            return promise;
+        };
+        executor(function(message, config, request) {
+            if (token.reason) return;
+            token.reason = new CanceledError(message, config, request);
+            resolvePromise(token.reason);
+        });
+    }
+    throwIfRequested() {
+        if (this.reason) throw this.reason;
+    }
+    subscribe(listener) {
+        if (this.reason) return void listener(this.reason);
+        if (this._listeners) this._listeners.push(listener);
+        else this._listeners = [
+            listener
+        ];
+    }
+    unsubscribe(listener) {
+        if (!this._listeners) return;
+        const index = this._listeners.indexOf(listener);
+        if (-1 !== index) this._listeners.splice(index, 1);
+    }
+    toAbortSignal() {
+        const controller = new AbortController();
+        const abort = (err)=>{
+            controller.abort(err);
+        };
+        this.subscribe(abort);
+        controller.signal.unsubscribe = ()=>this.unsubscribe(abort);
+        return controller.signal;
+    }
+    static source() {
+        let cancel;
+        const token = new CancelToken(function(c) {
+            cancel = c;
+        });
+        return {
+            token,
+            cancel
+        };
+    }
+}
+const cancel_CancelToken = CancelToken;
+function spread(callback) {
+    return function(arr) {
+        return callback.apply(null, arr);
+    };
+}
+function isAxiosError(payload) {
+    return utils.isObject(payload) && true === payload.isAxiosError;
+}
+const HttpStatusCode = {
+    Continue: 100,
+    SwitchingProtocols: 101,
+    Processing: 102,
+    EarlyHints: 103,
+    Ok: 200,
+    Created: 201,
+    Accepted: 202,
+    NonAuthoritativeInformation: 203,
+    NoContent: 204,
+    ResetContent: 205,
+    PartialContent: 206,
+    MultiStatus: 207,
+    AlreadyReported: 208,
+    ImUsed: 226,
+    MultipleChoices: 300,
+    MovedPermanently: 301,
+    Found: 302,
+    SeeOther: 303,
+    NotModified: 304,
+    UseProxy: 305,
+    Unused: 306,
+    TemporaryRedirect: 307,
+    PermanentRedirect: 308,
+    BadRequest: 400,
+    Unauthorized: 401,
+    PaymentRequired: 402,
+    Forbidden: 403,
+    NotFound: 404,
+    MethodNotAllowed: 405,
+    NotAcceptable: 406,
+    ProxyAuthenticationRequired: 407,
+    RequestTimeout: 408,
+    Conflict: 409,
+    Gone: 410,
+    LengthRequired: 411,
+    PreconditionFailed: 412,
+    PayloadTooLarge: 413,
+    UriTooLong: 414,
+    UnsupportedMediaType: 415,
+    RangeNotSatisfiable: 416,
+    ExpectationFailed: 417,
+    ImATeapot: 418,
+    MisdirectedRequest: 421,
+    UnprocessableEntity: 422,
+    Locked: 423,
+    FailedDependency: 424,
+    TooEarly: 425,
+    UpgradeRequired: 426,
+    PreconditionRequired: 428,
+    TooManyRequests: 429,
+    RequestHeaderFieldsTooLarge: 431,
+    UnavailableForLegalReasons: 451,
+    InternalServerError: 500,
+    NotImplemented: 501,
+    BadGateway: 502,
+    ServiceUnavailable: 503,
+    GatewayTimeout: 504,
+    HttpVersionNotSupported: 505,
+    VariantAlsoNegotiates: 506,
+    InsufficientStorage: 507,
+    LoopDetected: 508,
+    NotExtended: 510,
+    NetworkAuthenticationRequired: 511
+};
+Object.entries(HttpStatusCode).forEach(([key, value])=>{
+    HttpStatusCode[value] = key;
+});
+const helpers_HttpStatusCode = HttpStatusCode;
+function createInstance(defaultConfig) {
+    const context = new Axios(defaultConfig);
+    const instance = bind(Axios.prototype.request, context);
+    utils.extend(instance, Axios.prototype, context, {
+        allOwnKeys: true
+    });
+    utils.extend(instance, context, null, {
+        allOwnKeys: true
+    });
+    instance.create = function(instanceConfig) {
+        return createInstance(mergeConfig(defaultConfig, instanceConfig));
+    };
+    return instance;
+}
+const axios = createInstance(lib_defaults);
+axios.Axios = Axios;
+axios.CanceledError = CanceledError;
+axios.CancelToken = cancel_CancelToken;
+axios.isCancel = isCancel;
+axios.VERSION = VERSION;
+axios.toFormData = toFormData;
+axios.AxiosError = core_AxiosError;
+axios.Cancel = axios.CanceledError;
+axios.all = function(promises) {
+    return Promise.all(promises);
+};
+axios.spread = spread;
+axios.isAxiosError = isAxiosError;
+axios.mergeConfig = mergeConfig;
+axios.AxiosHeaders = core_AxiosHeaders;
+axios.formToJSON = (thing)=>formDataToJSON(utils.isHTMLForm(thing) ? new FormData(thing) : thing);
+axios.getAdapter = adapters_adapters.getAdapter;
+axios.HttpStatusCode = helpers_HttpStatusCode;
+axios.default = axios;
+const lib_axios = axios;
+class AmmoZeptoClient {
+    constructor(config){
+        this.config = config;
+        const { baseUrl, accessToken, perPage = 100 } = config;
+        if (!baseUrl || !accessToken) throw new Error('Invalid config');
+        this.client = lib_axios.create({
+            baseURL: this.config.baseUrl.replace(/\/$/, ''),
+            headers: {
+                Accepts: 'application/json',
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.config.accessToken}`,
+                'Per-Page': perPage
+            }
+        });
+    }
+    async getAllBankAccounts() {
+        const response = await this.client.get('/bank-accounts');
+        return response.data;
+    }
+}
+class AmmoZeptoBankAccounts extends AmmoZeptoClient {
+    constructor(config){
+        super(config), this.endpoint = '/bank_accounts';
+    }
+    async getAllBankAccounts() {
+        const response = await this.client.get(this.endpoint);
+        return response.data;
+    }
+}
+const generateMtaPaymentMethodAccountConfigForZepto = (payload)=>{
+    const { bsb, accountNumber, bankAccountId } = payload;
+    const maskedBsb = maskString(bsb, {
+        visibleStart: 0,
+        visibleEnd: 2
+    });
+    const maskedAccountNumber = maskString(accountNumber, {
+        visibleStart: 0,
+        visibleEnd: 2
+    });
+    return {
+        bsb: maskedBsb,
+        accountNumber: maskedAccountNumber,
+        credential: {
+            bankAccountId
+        }
+    };
+};
+const generateMtaPaymentMethodFloatAccountConfigForZepto = (payload)=>{
+    const { domainName, bankAccountId } = payload;
+    return {
+        domainName,
+        credential: {
+            bankAccountId
+        }
+    };
+};
+export { ASSIGN_UNKNOWN_TO_CUSTOMER, common_status_constant_AccountingCommonStatus as AccountingCommonStatus, AccountingCommonSyncStatus, AmmoZeptoBankAccounts, AmmoZeptoClient, CMAStatus, CreatePayoutSchema, MenuStatus, MenuType, mta_account_period_constant_MtaAccountPeriodStatus as MtaAccountPeriodStatus, MtaPayoutTransactionType, MtaReceiptTransactionType, mta_reconciliation_constant_MtaReconciliationStatus as MtaReconciliationStatus, mta_MtaStatus as MtaStatus, mta_input_type_constant_MtaTransactionInputType as MtaTransactionInputType, mta_payment_method_constant_MtaTransactionPaymentMethod as MtaTransactionPaymentMethod, MtaTransactionType, MtaTransactionTypeToDisplayTextMapper, ProjectApplyStatusRestRes, ProjectMtaAllocationStatus, PropertyRestResStatus, PropertyStage, reconcile_transaction_action_constant_ReconcileTransactionAction as ReconcileTransactionAction, TRANSACTION_CANCEL, allocateMtaToProjectRestReqSchema, approveMtaAllocationRestReqSchema, assignUnknownReceiptToPropertyRestReqSchema, basePayoutItemShape, cancelMtaTransactionRestReqSchema, cmaEntitySchema, cmaListRestResSchema, cmaTransactionEntitySchema, createCMARestReqSchema, createMenuRestReqSchema, createMtaReconciliationRestReqSchema, createMtaRestReqSchema, createMtaTransactionRestReqSchema, developerEntitySchema, formatCurrency, fromCentsToDollars, fromDollarsToCents, generateMtaPaymentMethodAccountConfigForZepto, generateMtaPaymentMethodFloatAccountConfigForZepto, getTransactionAmountStr, getTransactionNumber, getTransactionStatus, isPaymentTransaction, isReceiptTransaction, isTransactionAssignable, isTransactionCancelable, isUnknownReceiptAssignedToProperty, isUnknownTransaction, maskString, menuRestResSchema, menuSchema, mtaAccountPeriodCloseRestReqSchema, mtaAccountPeriodClosingSummaryRestReqSchema, mtaAccountPeriodClosingSummaryRestResSchema, mtaAccountPeriodEntitySchema, mtaAccountPeriodRestResSchema, mtaClosedAccountPeriodRestResSchema, mtaEntitySchema, mtaListItemRestResSchema, mtaPaymentMethodAccountConfigSchema, mtaPaymentMethodEntitySchema, mtaPaymentMethodFloatAccountConfigSchema, mtaPaymentMethodRestResSchema, mtaReconciledTransactionEntitySchema, mtaReconciledTransactionRestResSchema, mtaReconciliationEntitySchema, mtaReconciliationRestResSchema, mtaRestResSchema, mtaTransactionEntitySchema, mtaTransactionRestResSchema, paymentProviderEntitySchema, payoutDetailRestResSchema, payoutEntitySchema, payoutItemReqSchema, payoutListRestResSchema, payoutPaymentItemSchema, payoutRestReqSchema, payoutRestResSchema, payoutSourceDetailsSchema, payoutTargetDetailsSchema, payoutTransactionSchema, projectEntitySchema, projectMtaAllocationEntitySchema, projectMtaAllocationRestResSchema, projectRestResSchema, propertyEntitySchema, propertyListRestResSchema, propertyRestResSchema, provisionDetailsSchema, reconcileMtaTransactionRestReqSchema, updateMenuRestReqSchema, updateMtaAccountPeriodReconciledToRestReqSchema, updateMtaRestReqSchema, updateOpenReconciliationCurrentBankStatementBalanceRestReqSchema, userEntitySchema };