@taxdao/fintax-mcp 0.2.0

package/dist/schemas/domains/assets.js

@@ -0,0 +1,960 @@
+import { z } from 'zod/v4';
+import { contextSchema, viewPageSuccessEnvelopeSchema, successEnvelopeSchema, } from '../common.js';
+import { dateSchema, decimalStringSchema, upstreamDecimalSchema, uuidSchema, } from '../primitives.js';
+export const assetApprovalStatusSchema = z.enum([
+    'NONE',
+    'PENDING',
+    'APPROVED',
+    'REJECTED',
+    'WITHDRAWN',
+]);
+export const assetVerificationStatusSchema = z
+    .enum(['D', 'V', 'F'])
+    .describe('Upstream verification status code. Pass D, V, or F exactly as returned by the service.');
+export const assetMovementTypeSchema = z.enum([
+    'SOURCE',
+    'DEPR',
+    'IMPAIR',
+    'RETIRE',
+    'ADJUST',
+    'UNPLANNED',
+    'CATCHUP',
+    'RECLASS',
+    'REALLOC',
+]);
+export const assetFinanceIncludeSchema = z.enum([
+    'source_lines',
+    'allocation_lines',
+    'depreciation_details',
+]);
+export const assetListFiltersSchema = z
+    .object({
+    search: z.string().min(1).optional(),
+    ledger_id: z.uuid().optional(),
+    category_id: z.uuid().optional(),
+    asset_type: z.string().min(1).max(64).optional(),
+    in_use: z.boolean().optional(),
+    location: z.string().min(1).max(255).optional(),
+    approval_status: assetApprovalStatusSchema.optional(),
+})
+    .strict();
+export const assetMovementFiltersSchema = z
+    .object({
+    ledger_id: z.uuid(),
+    period_name: z.string().min(1).max(64).optional(),
+    movement_types: z.array(assetMovementTypeSchema).min(1).max(9).optional(),
+    search: z.string().min(1).max(255).optional(),
+    biz_date_from: dateSchema.optional(),
+    biz_date_to: dateSchema.optional(),
+})
+    .strict()
+    .superRefine((filters, context) => {
+    if (filters.biz_date_from !== undefined &&
+        filters.biz_date_to !== undefined &&
+        filters.biz_date_from > filters.biz_date_to) {
+        context.addIssue({
+            code: 'custom',
+            path: ['biz_date_to'],
+            message: 'biz_date_to must not be earlier than biz_date_from',
+        });
+    }
+    if (filters.movement_types !== undefined &&
+        new Set(filters.movement_types).size !== filters.movement_types.length) {
+        context.addIssue({
+            code: 'custom',
+            path: ['movement_types'],
+            message: 'movement_types must not contain duplicates',
+        });
+    }
+});
+export const queryAssetsInputSchema = z.discriminatedUnion('view', [
+    z
+        .object({
+        view: z.literal('list'),
+        filters: assetListFiltersSchema.default({}),
+        page: z.number().int().positive().default(1),
+        page_size: z.number().int().min(1).max(100).default(20),
+        context: contextSchema.optional(),
+    })
+        .strict()
+        .describe('Asset-card lists use a fixed order and do not support custom sorting; a page is not sorted again locally.'),
+    z
+        .object({
+        view: z.literal('detail'),
+        card_id: z.uuid(),
+        context: contextSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        view: z.literal('finance'),
+        finance_id: z.uuid(),
+        include: z
+            .array(assetFinanceIncludeSchema)
+            .max(3)
+            .default([])
+            .superRefine((values, context) => {
+            if (new Set(values).size !== values.length) {
+                context.addIssue({
+                    code: 'custom',
+                    message: 'include must not contain duplicates',
+                });
+            }
+        }),
+        context: contextSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        view: z.literal('movement_history'),
+        filters: assetMovementFiltersSchema,
+        page: z.number().int().positive().default(1),
+        page_size: z.number().int().min(1).max(100).default(20),
+        context: contextSchema.optional(),
+    })
+        .strict()
+        .describe('Asset-movement lists use a fixed order and do not support custom sorting; a page is not sorted again locally.'),
+]);
+const nullableUpstreamDecimalSchema = upstreamDecimalSchema.nullable();
+const nullableDecimalSchema = decimalStringSchema.nullable();
+const nullableStringSchema = z.string().nullable();
+const nullableUuidSchema = z.uuid().nullable();
+const nullableIntegerSchema = z.number().int().nullable();
+const auxiliaryFields = {
+    attribute1: z.string().nullable().optional(),
+    attribute2: z.string().nullable().optional(),
+    attribute3: z.string().nullable().optional(),
+    attribute4: z.string().nullable().optional(),
+    attribute5: z.string().nullable().optional(),
+    attribute6: z.string().nullable().optional(),
+    attribute7: z.string().nullable().optional(),
+    attribute8: z.string().nullable().optional(),
+    attribute9: z.string().nullable().optional(),
+    attribute10: z.string().nullable().optional(),
+    attribute11: z.string().nullable().optional(),
+    attribute12: z.string().nullable().optional(),
+};
+export const assetAuxiliarySchema = z
+    .object({
+    attribute1: nullableStringSchema,
+    attribute2: nullableStringSchema,
+    attribute3: nullableStringSchema,
+    attribute4: nullableStringSchema,
+    attribute5: nullableStringSchema,
+    attribute6: nullableStringSchema,
+    attribute7: nullableStringSchema,
+    attribute8: nullableStringSchema,
+    attribute9: nullableStringSchema,
+    attribute10: nullableStringSchema,
+    attribute11: nullableStringSchema,
+    attribute12: nullableStringSchema,
+})
+    .strict();
+export const assetWorkbenchRowUpstreamSchema = z
+    .object({
+    asset_finance_id: z.uuid().nullable(),
+    card_id: z.uuid(),
+    asset_no: z.string(),
+    description: z.string().nullable().optional(),
+    tag_no: z.string().nullable().optional(),
+    ledger_id: z.uuid().nullable().optional(),
+    ledger_name: z.string().nullable().optional(),
+    category_id: z.uuid().nullable().optional(),
+    category_name: z.string().nullable().optional(),
+    asset_type: z.string().nullable().optional(),
+    location: z.string().nullable().optional(),
+    quantity: nullableUpstreamDecimalSchema,
+    original_cost: nullableUpstreamDecimalSchema,
+    nbv: nullableUpstreamDecimalSchema,
+    accum_depr: nullableUpstreamDecimalSchema,
+    in_use: z.boolean(),
+    version: z.number().int().nullable().optional(),
+    card_attachment_count: z.number().int().nonnegative().default(0),
+    finance_attachment_count: z.number().int().nonnegative().default(0),
+    approval_status: assetApprovalStatusSchema.nullable().optional(),
+    verification_status: assetVerificationStatusSchema.nullable().optional(),
+    finance_approval_status: assetApprovalStatusSchema.nullable().optional(),
+    finance_verification_status: assetVerificationStatusSchema
+        .nullable()
+        .optional(),
+})
+    .passthrough();
+export const assetWorkbenchListUpstreamSchema = z
+    .object({
+    list: z.array(assetWorkbenchRowUpstreamSchema),
+    total: z.number().int().nonnegative(),
+    page: z.number().int().positive(),
+    page_size: z.number().int().positive().optional(),
+    pageSize: z.number().int().positive().optional(),
+})
+    .passthrough();
+export const assetCardUpstreamSchema = z
+    .object({
+    id: z.uuid(),
+    asset_no: z.string(),
+    tag_no: z.string().nullable().optional(),
+    serial_no: z.string().nullable().optional(),
+    asset_type: z.string().nullable().optional(),
+    category_id: z.uuid().nullable().optional(),
+    category_name: z.string().nullable().optional(),
+    manufacturer: z.string().nullable().optional(),
+    asset_name: z.string().nullable().optional(),
+    in_use: z.boolean(),
+    description: z.string().nullable().optional(),
+    asset_key_field: z.string().nullable().optional(),
+    quantity: nullableUpstreamDecimalSchema,
+    unit: z.string().nullable().optional(),
+    location: z.string().nullable().optional(),
+    version: z.number().int().nullable().optional(),
+    approval_status: assetApprovalStatusSchema.nullable().optional(),
+    verification_status: assetVerificationStatusSchema.nullable().optional(),
+    approved_by: z.uuid().nullable().optional(),
+    approved_at: z.string().nullable().optional(),
+})
+    .passthrough();
+const financeCoaFields = {
+    asset_cost_coa_code: z.string().nullable().optional(),
+    asset_clearing_coa_code: z.string().nullable().optional(),
+    depr_expense_coa_code: z.string().nullable().optional(),
+    accum_depr_coa_code: z.string().nullable().optional(),
+    addl_expense_coa_code: z.string().nullable().optional(),
+    addl_reserve_coa_code: z.string().nullable().optional(),
+    reval_reserve_coa_code: z.string().nullable().optional(),
+    cip_cost_coa_code: z.string().nullable().optional(),
+    cip_clearing_coa_code: z.string().nullable().optional(),
+    accum_impair_coa_code: z.string().nullable().optional(),
+    unplanned_depr_coa_code: z.string().nullable().optional(),
+    writeoff_coa_code: z.string().nullable().optional(),
+};
+export const assetFinanceUpstreamSchema = z
+    .object({
+    id: z.uuid(),
+    card_id: z.uuid(),
+    category_id: z.uuid().nullable().optional(),
+    category_name: z.string().nullable().optional(),
+    ledger_id: z.uuid().nullable().optional(),
+    ledger_name: z.string().nullable().optional(),
+    remark: z.string().nullable().optional(),
+    current_cost: nullableUpstreamDecimalSchema,
+    original_cost: nullableUpstreamDecimalSchema,
+    salvage_type: z.string().nullable().optional(),
+    salvage_pct: nullableUpstreamDecimalSchema,
+    salvage_value: nullableUpstreamDecimalSchema,
+    recoverable_cost: nullableUpstreamDecimalSchema,
+    nbv: nullableUpstreamDecimalSchema,
+    ytd_depr: nullableUpstreamDecimalSchema,
+    accum_depr: nullableUpstreamDecimalSchema,
+    accum_impair: nullableUpstreamDecimalSchema,
+    accum_retire: nullableUpstreamDecimalSchema,
+    depr_method_id: z.uuid().nullable().optional(),
+    useful_life_years: z.number().int().nullable().optional(),
+    months: z.number().int().nullable().optional(),
+    depr_flag: z.boolean(),
+    disabled_flag: z.boolean(),
+    start_date: dateSchema.nullable().optional(),
+    depr_start_rule: z.string().nullable().optional(),
+    retire_rule: z.string().nullable().optional(),
+    amortize_adjust: z.boolean().nullable().optional(),
+    cap_limit: nullableUpstreamDecimalSchema,
+    ...financeCoaFields,
+    version: z.number().int().nullable().optional(),
+    approval_status: assetApprovalStatusSchema.nullable().optional(),
+    verification_status: assetVerificationStatusSchema.nullable().optional(),
+    approved_by: z.uuid().nullable().optional(),
+    approved_at: z.string().nullable().optional(),
+})
+    .passthrough();
+export const assetFinanceListUpstreamSchema = z
+    .object({ list: z.array(assetFinanceUpstreamSchema) })
+    .passthrough();
+export const assetSourceLineUpstreamSchema = z
+    .object({
+    id: z.uuid(),
+    asset_finance_id: z.uuid(),
+    line_no: z.number().int().nullable().optional(),
+    invoice_no: z.string().nullable().optional(),
+    invoice_line_no: z.number().int().nullable().optional(),
+    party_id: z.uuid().nullable().optional(),
+    party_name: z.string().nullable().optional(),
+    party_code: z.string().nullable().optional(),
+    description: z.string().nullable().optional(),
+    line_amount: nullableUpstreamDecimalSchema,
+    version: z.number().int().nullable().optional(),
+})
+    .passthrough();
+export const assetSourceLinesUpstreamSchema = z
+    .object({
+    lines: z.array(assetSourceLineUpstreamSchema),
+    original_cost: nullableUpstreamDecimalSchema,
+})
+    .passthrough();
+export const assetAllocationLineUpstreamSchema = z
+    .object({
+    id: z.uuid(),
+    asset_finance_id: z.uuid(),
+    line_no: z.number().int().nullable().optional(),
+    quantity: nullableUpstreamDecimalSchema,
+    employee_name: z.string().nullable().optional(),
+    depr_expense_coa_code: z.string().nullable().optional(),
+    ...auxiliaryFields,
+    description: z.string().nullable().optional(),
+    reference: z.string().nullable().optional(),
+    remark: z.string().nullable().optional(),
+    version: z.number().int().nullable().optional(),
+})
+    .passthrough();
+export const assetAllocationLinesUpstreamSchema = z
+    .object({
+    lines: z.array(assetAllocationLineUpstreamSchema),
+    total_quantity: nullableUpstreamDecimalSchema,
+})
+    .passthrough();
+export const assetMovementEventUpstreamSchema = z
+    .object({
+    event_id: z.uuid(),
+    event_no: z.string(),
+    event_time: z.string().nullable(),
+    event_type: z.string(),
+    entry_source: z.string(),
+})
+    .passthrough();
+export const assetMovementJournalUpstreamSchema = z
+    .object({
+    journal_id: z.uuid(),
+    journal_number: z.string().nullable(),
+    period_name: z.string().nullable(),
+    approval_status: z.string().nullable(),
+    ledger_id: z.uuid().nullable(),
+    event_id: z.uuid().nullable(),
+})
+    .passthrough();
+export const assetDepreciationDetailUpstreamSchema = z
+    .object({
+    id: z.uuid(),
+    movement_type: z.string(),
+    amount: nullableUpstreamDecimalSchema,
+    biz_date: dateSchema.nullable().optional(),
+    period_name: z.string().nullable().optional(),
+    fiscal_year: z.string().nullable().optional(),
+    periods_covered: z.number().int().nullable().optional(),
+    alloc_line_id: z.uuid().nullable().optional(),
+    quantity: nullableUpstreamDecimalSchema,
+    description: z.string().nullable().optional(),
+    reference: z.string().nullable().optional(),
+    remark: z.string().nullable().optional(),
+    coa_code: z.string().nullable().optional(),
+    ...auxiliaryFields,
+    events: z.array(assetMovementEventUpstreamSchema).default([]),
+    journals: z.array(assetMovementJournalUpstreamSchema).default([]),
+})
+    .passthrough();
+export const assetDepreciationSummaryUpstreamSchema = z
+    .object({
+    asset_finance_id: z.uuid(),
+    ledger_id: z.uuid().nullable(),
+    asset_no: z.string().nullable(),
+    tag_no: z.string().nullable(),
+    description: z.string().nullable(),
+    ledger_name: z.string().nullable(),
+    currency: z.string().nullable(),
+    original_cost: nullableUpstreamDecimalSchema,
+    recoverable_cost: nullableUpstreamDecimalSchema,
+    nbv: nullableUpstreamDecimalSchema,
+    ytd_depr: nullableUpstreamDecimalSchema,
+    accum_depr: nullableUpstreamDecimalSchema,
+})
+    .passthrough();
+export const assetDepreciationDetailsUpstreamSchema = z
+    .object({
+    summary: assetDepreciationSummaryUpstreamSchema.nullable(),
+    list: z.array(assetDepreciationDetailUpstreamSchema),
+})
+    .passthrough();
+export const assetMovementRowUpstreamSchema = z
+    .object({
+    id: z.uuid(),
+    asset_finance_id: z.uuid().nullable(),
+    card_id: z.uuid().nullable(),
+    alloc_line_id: z.uuid().nullable(),
+    asset_no: z.string(),
+    asset_description: z.string().nullable(),
+    tag_no: z.string().nullable(),
+    ledger_id: z.uuid().nullable(),
+    ledger_name: z.string().nullable(),
+    currency: z.string().nullable(),
+    movement_type: z.string(),
+    origin_movement_type: z.string().nullable(),
+    employee_name: z.string().nullable(),
+    coa_code: z.string().nullable(),
+    biz_date: dateSchema.nullable(),
+    period_name: z.string().nullable(),
+    derived_period_name: z.string().nullable(),
+    fiscal_year: z.string().nullable(),
+    periods_covered: z.number().int().nullable(),
+    quantity: nullableUpstreamDecimalSchema,
+    amount: nullableUpstreamDecimalSchema,
+    is_reversed: z.boolean(),
+    reverse_of_id: z.uuid().nullable(),
+    remark: z.string().nullable(),
+    aux: z.object(auxiliaryFields).passthrough().default({}),
+    events: z.array(assetMovementEventUpstreamSchema).default([]),
+    journals: z.array(assetMovementJournalUpstreamSchema).default([]),
+})
+    .passthrough();
+export const assetMovementListUpstreamSchema = z
+    .object({
+    list: z.array(assetMovementRowUpstreamSchema),
+    total: z.number().int().nonnegative(),
+    page: z.number().int().positive(),
+    page_size: z.number().int().positive().optional(),
+    pageSize: z.number().int().positive().optional(),
+    summary: z
+        .object({
+        total_amount: upstreamDecimalSchema,
+        row_count: z.number().int().nonnegative(),
+    })
+        .passthrough(),
+})
+    .passthrough();
+export const assetWorkbenchRowSchema = z
+    .object({
+    asset_finance_id: nullableUuidSchema,
+    card_id: z.uuid(),
+    asset_no: z.string(),
+    description: nullableStringSchema,
+    tag_no: nullableStringSchema,
+    ledger_id: nullableUuidSchema,
+    ledger_name: nullableStringSchema,
+    category_id: nullableUuidSchema,
+    category_name: nullableStringSchema,
+    asset_type: nullableStringSchema,
+    location: nullableStringSchema,
+    quantity: nullableDecimalSchema,
+    original_cost: nullableDecimalSchema,
+    nbv: nullableDecimalSchema,
+    accum_depr: nullableDecimalSchema,
+    in_use: z.boolean(),
+    version: nullableIntegerSchema,
+    card_attachment_count: z.number().int().nonnegative(),
+    finance_attachment_count: z.number().int().nonnegative(),
+    approval_status: assetApprovalStatusSchema.nullable(),
+    verification_status: assetVerificationStatusSchema.nullable(),
+    finance_approval_status: assetApprovalStatusSchema.nullable(),
+    finance_verification_status: assetVerificationStatusSchema.nullable(),
+})
+    .strict();
+export const assetCardSchema = z
+    .object({
+    id: z.uuid(),
+    asset_no: z.string(),
+    tag_no: nullableStringSchema,
+    serial_no: nullableStringSchema,
+    asset_type: nullableStringSchema,
+    category_id: nullableUuidSchema,
+    category_name: nullableStringSchema,
+    manufacturer: nullableStringSchema,
+    asset_name: nullableStringSchema,
+    in_use: z.boolean(),
+    description: nullableStringSchema,
+    asset_key_field: nullableStringSchema,
+    quantity: nullableDecimalSchema,
+    unit: nullableStringSchema,
+    location: nullableStringSchema,
+    version: nullableIntegerSchema,
+    approval_status: assetApprovalStatusSchema.nullable(),
+    verification_status: assetVerificationStatusSchema.nullable(),
+    approved_by: nullableUuidSchema,
+    approved_at: nullableStringSchema,
+})
+    .strict();
+export const assetFinanceCoaAccountsSchema = z
+    .object({
+    asset_cost: nullableStringSchema,
+    asset_clearing: nullableStringSchema,
+    depreciation_expense: nullableStringSchema,
+    accumulated_depreciation: nullableStringSchema,
+    additional_expense: nullableStringSchema,
+    additional_reserve: nullableStringSchema,
+    revaluation_reserve: nullableStringSchema,
+    cip_cost: nullableStringSchema,
+    cip_clearing: nullableStringSchema,
+    accumulated_impairment: nullableStringSchema,
+    unplanned_depreciation: nullableStringSchema,
+    writeoff: nullableStringSchema,
+})
+    .strict();
+export const assetFinanceSchema = z
+    .object({
+    id: z.uuid(),
+    card_id: z.uuid(),
+    category_id: nullableUuidSchema,
+    category_name: nullableStringSchema,
+    ledger_id: nullableUuidSchema,
+    ledger_name: nullableStringSchema,
+    remark: nullableStringSchema,
+    current_cost: nullableDecimalSchema,
+    original_cost: nullableDecimalSchema,
+    salvage_type: nullableStringSchema,
+    salvage_pct: nullableDecimalSchema,
+    salvage_value: nullableDecimalSchema,
+    recoverable_cost: nullableDecimalSchema,
+    nbv: nullableDecimalSchema,
+    ytd_depr: nullableDecimalSchema,
+    accum_depr: nullableDecimalSchema,
+    accum_impair: nullableDecimalSchema,
+    accum_retire: nullableDecimalSchema,
+    depr_method_id: nullableUuidSchema,
+    useful_life_years: nullableIntegerSchema,
+    months: nullableIntegerSchema,
+    depr_flag: z.boolean(),
+    disabled_flag: z.boolean(),
+    start_date: dateSchema.nullable(),
+    depr_start_rule: nullableStringSchema,
+    retire_rule: nullableStringSchema,
+    amortize_adjust: z.boolean().nullable(),
+    cap_limit: nullableDecimalSchema,
+    coa_accounts: assetFinanceCoaAccountsSchema,
+    version: nullableIntegerSchema,
+    approval_status: assetApprovalStatusSchema.nullable(),
+    verification_status: assetVerificationStatusSchema.nullable(),
+    approved_by: nullableUuidSchema,
+    approved_at: nullableStringSchema,
+})
+    .strict();
+export const assetSourceLinesSchema = z
+    .object({
+    original_cost: nullableDecimalSchema,
+    lines: z.array(z
+        .object({
+        id: z.uuid(),
+        asset_finance_id: z.uuid(),
+        line_no: nullableIntegerSchema,
+        invoice_no: nullableStringSchema,
+        invoice_line_no: nullableIntegerSchema,
+        party_id: nullableUuidSchema,
+        party_name: nullableStringSchema,
+        party_code: nullableStringSchema,
+        description: nullableStringSchema,
+        line_amount: nullableDecimalSchema,
+        version: nullableIntegerSchema,
+    })
+        .strict()),
+})
+    .strict();
+export const assetAllocationLinesSchema = z
+    .object({
+    total_quantity: nullableDecimalSchema,
+    lines: z.array(z
+        .object({
+        id: z.uuid(),
+        asset_finance_id: z.uuid(),
+        line_no: nullableIntegerSchema,
+        quantity: nullableDecimalSchema,
+        employee_name: nullableStringSchema,
+        depr_expense_coa_code: nullableStringSchema,
+        attributes: assetAuxiliarySchema,
+        description: nullableStringSchema,
+        reference: nullableStringSchema,
+        remark: nullableStringSchema,
+        version: nullableIntegerSchema,
+    })
+        .strict()),
+})
+    .strict();
+export const assetMovementEventSchema = z
+    .object({
+    event_id: z.uuid(),
+    event_no: z.string(),
+    event_time: nullableStringSchema,
+    event_type: z.string(),
+    entry_source: z.string(),
+})
+    .strict();
+export const assetMovementJournalSchema = z
+    .object({
+    journal_id: z.uuid(),
+    journal_number: nullableStringSchema,
+    period_name: nullableStringSchema,
+    approval_status: nullableStringSchema,
+    ledger_id: nullableUuidSchema,
+    event_id: nullableUuidSchema,
+})
+    .strict();
+export const assetDepreciationDetailsSchema = z
+    .object({
+    summary: z
+        .object({
+        asset_finance_id: z.uuid(),
+        ledger_id: nullableUuidSchema,
+        asset_no: nullableStringSchema,
+        tag_no: nullableStringSchema,
+        description: nullableStringSchema,
+        ledger_name: nullableStringSchema,
+        currency: nullableStringSchema,
+        original_cost: nullableDecimalSchema,
+        recoverable_cost: nullableDecimalSchema,
+        nbv: nullableDecimalSchema,
+        ytd_depr: nullableDecimalSchema,
+        accum_depr: nullableDecimalSchema,
+    })
+        .strict()
+        .nullable(),
+    items: z.array(z
+        .object({
+        id: z.uuid(),
+        movement_type: z.string(),
+        amount: nullableDecimalSchema,
+        biz_date: dateSchema.nullable(),
+        period_name: nullableStringSchema,
+        fiscal_year: nullableStringSchema,
+        periods_covered: nullableIntegerSchema,
+        alloc_line_id: nullableUuidSchema,
+        quantity: nullableDecimalSchema,
+        coa_code: nullableStringSchema,
+        attributes: assetAuxiliarySchema,
+        description: nullableStringSchema,
+        reference: nullableStringSchema,
+        remark: nullableStringSchema,
+        events: z.array(assetMovementEventSchema),
+        journals: z.array(assetMovementJournalSchema),
+    })
+        .strict()),
+})
+    .strict();
+export const assetMovementRowSchema = z
+    .object({
+    id: z.uuid(),
+    asset_finance_id: nullableUuidSchema,
+    card_id: nullableUuidSchema,
+    alloc_line_id: nullableUuidSchema,
+    asset_no: z.string(),
+    asset_description: nullableStringSchema,
+    tag_no: nullableStringSchema,
+    ledger_id: nullableUuidSchema,
+    ledger_name: nullableStringSchema,
+    currency: nullableStringSchema,
+    movement_type: z.string(),
+    origin_movement_type: nullableStringSchema,
+    employee_name: nullableStringSchema,
+    coa_code: nullableStringSchema,
+    biz_date: dateSchema.nullable(),
+    period_name: nullableStringSchema,
+    derived_period_name: nullableStringSchema,
+    fiscal_year: nullableStringSchema,
+    periods_covered: nullableIntegerSchema,
+    quantity: nullableDecimalSchema,
+    amount: nullableDecimalSchema,
+    is_reversed: z.boolean(),
+    reverse_of_id: nullableUuidSchema,
+    remark: nullableStringSchema,
+    attributes: assetAuxiliarySchema,
+    events: z.array(assetMovementEventSchema),
+    journals: z.array(assetMovementJournalSchema),
+})
+    .strict();
+export const queryAssetsOutputSchema = viewPageSuccessEnvelopeSchema(z.discriminatedUnion('view', [
+    z
+        .object({
+        view: z.literal('list'),
+        items: z.array(assetWorkbenchRowSchema),
+    })
+        .strict(),
+    z
+        .object({
+        view: z.literal('detail'),
+        card: assetCardSchema,
+        finances: z.array(assetFinanceSchema).nullable(),
+    })
+        .strict(),
+    z
+        .object({
+        view: z.literal('finance'),
+        finance: assetFinanceSchema,
+        include: z.array(assetFinanceIncludeSchema),
+        source_lines: assetSourceLinesSchema.nullable().optional(),
+        allocation_lines: assetAllocationLinesSchema.nullable().optional(),
+        depreciation_details: assetDepreciationDetailsSchema
+            .nullable()
+            .optional(),
+    })
+        .strict(),
+    z
+        .object({
+        view: z.literal('movement_history'),
+        items: z.array(assetMovementRowSchema),
+        summary: z
+            .object({
+            total_amount: decimalStringSchema,
+            row_count: z.number().int().nonnegative(),
+        })
+            .strict(),
+    })
+        .strict(),
+]), ['list', 'movement_history']);
+const writeContextSchema = z.object({ org_id: uuidSchema }).strict();
+const optionalText = (max) => z.string().max(max).optional();
+const nonNegativeDecimalSchema = decimalStringSchema.refine((value) => !value.startsWith('-'), 'Must be a non-negative decimal string');
+const cardShape = {
+    asset_no: z.string().min(1).max(64),
+    tag_no: optionalText(64),
+    serial_no: optionalText(128),
+    asset_type: optionalText(64),
+    category_id: uuidSchema,
+    manufacturer: optionalText(128),
+    asset_name: optionalText(50),
+    in_use: z.boolean().optional(),
+    description: optionalText(512),
+    asset_key_field: optionalText(128),
+    quantity: nonNegativeDecimalSchema.optional(),
+    unit: optionalText(32),
+    location: optionalText(200),
+};
+export const assetCardSaveValuesSchema = z.object(cardShape).strict();
+export const assetCardCreateValuesSchema = assetCardSaveValuesSchema.extend({
+    attachment_file_ids: z.array(uuidSchema).max(10).optional(),
+});
+const coaAccountsSchema = z
+    .object({
+    asset_cost: optionalText(50),
+    asset_clearing: optionalText(50),
+    depreciation_expense: optionalText(50),
+    accumulated_depreciation: optionalText(50),
+    additional_expense: optionalText(50),
+    additional_reserve: optionalText(50),
+    revaluation_reserve: optionalText(50),
+    cip_cost: optionalText(50),
+    cip_clearing: optionalText(50),
+    accumulated_impairment: optionalText(50),
+    unplanned_depreciation: optionalText(50),
+    writeoff: optionalText(50),
+})
+    .strict()
+    .optional();
+export const assetFinanceSaveValuesSchema = z
+    .object({
+    category_id: uuidSchema.optional(),
+    remark: optionalText(512),
+    current_cost: decimalStringSchema.optional(),
+    original_cost: nonNegativeDecimalSchema.optional(),
+    salvage_type: optionalText(32),
+    salvage_pct: nonNegativeDecimalSchema.optional(),
+    salvage_value: nonNegativeDecimalSchema.optional(),
+    ytd_depr: decimalStringSchema.optional(),
+    accum_depr: decimalStringSchema.optional(),
+    depr_method_id: uuidSchema.optional(),
+    useful_life_years: z.number().int().nonnegative().optional(),
+    months: z.number().int().nonnegative().optional(),
+    depr_flag: z.boolean().optional(),
+    disabled_flag: z.boolean().optional(),
+    start_date: dateSchema.optional(),
+    depr_start_rule: optionalText(32),
+    retire_rule: optionalText(32),
+    amortize_adjust: z.boolean().optional(),
+    cap_limit: nonNegativeDecimalSchema.optional(),
+    coa_accounts: coaAccountsSchema,
+})
+    .strict();
+export const assetFinanceCreateValuesSchema = assetFinanceSaveValuesSchema.extend({
+    attachment_file_ids: z.array(uuidSchema).max(10).optional(),
+});
+export const assetSourceLineInputSchema = z
+    .object({
+    line_no: z.number().int().positive(),
+    invoice_no: z.string().min(1).max(100),
+    invoice_line_no: z.number().int().positive(),
+    line_amount: decimalStringSchema.optional(),
+    description: optionalText(512),
+})
+    .strict();
+export const assetAllocationLineInputSchema = z
+    .object({
+    id: uuidSchema.optional(),
+    line_no: z.number().int().positive().optional(),
+    quantity: nonNegativeDecimalSchema,
+    employee_name: optionalText(200),
+    depr_expense_coa_code: optionalText(50),
+    attributes: z.array(z.string().max(255).nullable()).max(12).optional(),
+    description: optionalText(512),
+    reference: optionalText(256),
+    remark: optionalText(512),
+})
+    .strict();
+const saveBaseShape = {
+    context: writeContextSchema,
+    idempotency_key: uuidSchema,
+};
+export const saveAssetInputSchema = z.discriminatedUnion('target', [
+    z
+        .object({
+        target: z.literal('card'),
+        ...saveBaseShape,
+        mutation: z.discriminatedUnion('operation', [
+            z
+                .object({
+                operation: z.literal('create'),
+                values: assetCardCreateValuesSchema,
+            })
+                .strict(),
+            z
+                .object({
+                operation: z.literal('update'),
+                card_id: uuidSchema,
+                version: z.number().int().nonnegative(),
+                values: assetCardSaveValuesSchema,
+            })
+                .strict(),
+        ]),
+    })
+        .strict(),
+    z
+        .object({
+        target: z.literal('finance'),
+        ...saveBaseShape,
+        mutation: z.discriminatedUnion('operation', [
+            z
+                .object({
+                operation: z.literal('create'),
+                card_id: uuidSchema,
+                values: assetFinanceCreateValuesSchema,
+            })
+                .strict(),
+            z
+                .object({
+                operation: z.literal('update'),
+                finance_id: uuidSchema,
+                version: z.number().int().nonnegative(),
+                values: assetFinanceSaveValuesSchema,
+            })
+                .strict(),
+        ]),
+    })
+        .strict(),
+    z
+        .object({
+        target: z.literal('source_lines'),
+        ...saveBaseShape,
+        mutation: z.discriminatedUnion('operation', [
+            z
+                .object({
+                operation: z.literal('add'),
+                finance_id: uuidSchema,
+                lines: z.array(assetSourceLineInputSchema).min(1).max(500),
+            })
+                .strict(),
+            z
+                .object({
+                operation: z.literal('replace'),
+                finance_id: uuidSchema,
+                lines: z.array(assetSourceLineInputSchema).min(1).max(500),
+            })
+                .strict(),
+        ]),
+    })
+        .strict(),
+    z
+        .object({
+        target: z.literal('allocation_lines'),
+        ...saveBaseShape,
+        mutation: z
+            .object({
+            operation: z.literal('replace'),
+            finance_id: uuidSchema,
+            lines: z.array(assetAllocationLineInputSchema).min(1).max(500),
+        })
+            .strict(),
+    })
+        .strict(),
+]);
+const specializedAssetWriteBaseShape = {
+    context: writeContextSchema,
+    idempotency_key: uuidSchema,
+};
+export const saveAssetCardInputSchema = z.discriminatedUnion('operation', [
+    z
+        .object({
+        operation: z.literal('create'),
+        ...specializedAssetWriteBaseShape,
+        values: assetCardCreateValuesSchema,
+    })
+        .strict(),
+    z
+        .object({
+        operation: z.literal('update'),
+        ...specializedAssetWriteBaseShape,
+        card_id: uuidSchema,
+        version: z.number().int().nonnegative(),
+        values: assetCardSaveValuesSchema,
+    })
+        .strict(),
+]);
+export const saveAssetFinanceInputSchema = z.discriminatedUnion('operation', [
+    z
+        .object({
+        operation: z.literal('create'),
+        ...specializedAssetWriteBaseShape,
+        card_id: uuidSchema,
+        values: assetFinanceCreateValuesSchema,
+    })
+        .strict(),
+    z
+        .object({
+        operation: z.literal('update'),
+        ...specializedAssetWriteBaseShape,
+        finance_id: uuidSchema,
+        version: z.number().int().nonnegative(),
+        values: assetFinanceSaveValuesSchema,
+    })
+        .strict(),
+]);
+export const saveAssetSourceLinesInputSchema = z
+    .object({
+    operation: z.enum(['add', 'replace']),
+    ...specializedAssetWriteBaseShape,
+    finance_id: uuidSchema,
+    lines: z.array(assetSourceLineInputSchema).min(1).max(500),
+})
+    .strict();
+export const replaceAssetAllocationLinesInputSchema = z
+    .object({
+    ...specializedAssetWriteBaseShape,
+    finance_id: uuidSchema,
+    lines: z.array(assetAllocationLineInputSchema).min(1).max(500),
+})
+    .strict();
+export const saveAssetCardOutputSchema = successEnvelopeSchema(z
+    .object({
+    operation: z.enum(['created', 'updated']),
+    card: z
+        .object({
+        id: uuidSchema,
+        version: z.number().int().nonnegative().nullable(),
+    })
+        .strict(),
+})
+    .strict());
+export const saveAssetFinanceOutputSchema = successEnvelopeSchema(z
+    .object({
+    operation: z.enum(['created', 'updated']),
+    finance: z
+        .object({
+        id: uuidSchema,
+        version: z.number().int().nonnegative().nullable(),
+    })
+        .strict(),
+})
+    .strict());
+export const saveAssetSourceLinesOutputSchema = successEnvelopeSchema(z
+    .object({
+    operation: z.enum(['added', 'replaced']),
+    finance_id: uuidSchema,
+    line_count: z.number().int().nonnegative(),
+})
+    .strict());
+export const replaceAssetAllocationLinesOutputSchema = successEnvelopeSchema(z
+    .object({
+    operation: z.literal('replaced'),
+    finance_id: uuidSchema,
+    line_count: z.number().int().nonnegative(),
+})
+    .strict());
+//# sourceMappingURL=assets.js.map