@taxdao/fintax-mcp 0.2.0

package/dist/capabilities/definitions/extended-operation-contracts.js

@@ -0,0 +1,1180 @@
+import { z } from 'zod/v4';
+import { dateSchema, upstreamDecimalSchema, uuidSchema, } from '../../schemas/primitives.js';
+const integer = z.number().int();
+const nonNegativeInteger = integer.nonnegative();
+const version = nonNegativeInteger;
+const optionalText = z.string().nullable().optional();
+const optionalUuid = uuidSchema.nullable().optional();
+const optionalTimestamp = z.string().nullable().optional();
+const decimal = upstreamDecimalSchema;
+const optionalDecimal = decimal.nullable().optional();
+const queryValue = z.union([z.string(), z.number(), z.boolean()]).optional();
+const query = z.record(z.string(), queryValue);
+const idRequest = (key) => z.object({ [key]: uuidSchema }).strict();
+const queryRequest = z.object({ query }).strict();
+const bodyRequest = (body) => z.object({ body }).strict();
+const idBodyRequest = (key, body) => z.object({ [key]: uuidSchema, body }).strict();
+const page = (item) => z
+    .object({
+    total: nonNegativeInteger,
+    page: integer.positive(),
+    page_size: integer.positive(),
+    items: z.array(item),
+})
+    .passthrough();
+const submitResult = z
+    .object({
+    binding_id: uuidSchema,
+    instance_id: z.string(),
+    approval_status: z.string(),
+    current_node_name: optionalText,
+})
+    .passthrough();
+const verificationResult = z
+    .object({ verification_status: z.string() })
+    .passthrough();
+const verifyAndSubmitResponse = z
+    .object({
+    verified: z.boolean(),
+    submitted: z.boolean(),
+    failed_at: optionalText,
+    error_code: optionalText,
+    message: optionalText,
+    verify_result: verificationResult.nullable().optional(),
+    submit_result: submitResult.nullable().optional(),
+})
+    .passthrough();
+const journalVerifyAndSubmitResponse = verifyAndSubmitResponse.extend({
+    verify_result: z
+        .object({ journal_id: uuidSchema, verification_status: z.string() })
+        .passthrough()
+        .nullable()
+        .optional(),
+});
+const batchSubmitResponse = z
+    .object({
+    submitted: nonNegativeInteger,
+    failed: z.array(z
+        .object({
+        journal_id: uuidSchema,
+        journal_number: optionalText,
+        reason: z.string(),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const postItem = z
+    .object({
+    status: z.enum(['POSTED', 'NO_EVENT', 'NOT_POSTED']),
+    reason: optionalText,
+    journals: nonNegativeInteger,
+})
+    .passthrough();
+const documentPostResponse = z
+    .object({
+    requested: nonNegativeInteger,
+    posted: nonNegativeInteger,
+    journals: nonNegativeInteger,
+    items: z.array(postItem),
+    attachments_copied: nonNegativeInteger,
+    attachments_skipped: nonNegativeInteger,
+    attachments_failed: nonNegativeInteger,
+})
+    .passthrough();
+const offsetCandidate = z
+    .object({
+    source_type: z.string(),
+    source_id: uuidSchema,
+    symbol: z.string(),
+    quantity: decimal,
+    base_amount: optionalDecimal,
+    base_currency: optionalText,
+    base_rate: optionalDecimal,
+    biz_date: optionalTimestamp,
+    source_ref: optionalText,
+    main_account_name: optionalText,
+    sub_account_code: optionalText,
+})
+    .passthrough();
+const offsetCandidatesResponse = z
+    .object({
+    invoice_symbols: z.array(z.string()),
+    groups: z.array(z
+        .object({ symbol: z.string(), candidates: z.array(offsetCandidate) })
+        .passthrough()),
+})
+    .passthrough();
+const offsetApplyResponse = z
+    .object({
+    offset_lines: z.array(z
+        .object({
+        offset_line_id: uuidSchema,
+        source_type: z.string(),
+        source_id: uuidSchema,
+        quantity: decimal,
+        symbol: z.string(),
+        base_amount: optionalDecimal,
+    })
+        .passthrough()),
+    diff_lines: z.array(z.object({ offset_line_id: uuidSchema }).passthrough()),
+    invoice_remaining: z.array(z.object({ symbol: z.string(), remaining: decimal }).passthrough()),
+    offset_date: z.string(),
+    gl_date: z.string(),
+})
+    .passthrough();
+const offsetBody = z
+    .object({
+    txnRefs: z.array(z.object({ sourceType: z.string(), sourceId: uuidSchema }).strict()),
+    offsetDate: z.string(),
+    glDate: z.string(),
+    mode: z.literal('APPEND'),
+    periodName: z.string().optional(),
+})
+    .strict();
+const closingView = z
+    .object({
+    id: uuidSchema,
+    period_name: z.string(),
+    org_id: uuidSchema,
+    org_name: optionalText,
+    ledger_id: uuidSchema,
+    ledger_code: optionalText,
+    ledger_name: optionalText,
+    p_glh_id: optionalUuid,
+    closing_status: z.enum(['OPEN', 'CLOSED']),
+    revaluation_status: z.string(),
+    reconcile_status: z.string(),
+    revaluation_by: optionalUuid,
+    revaluation_time: optionalTimestamp,
+    import_status: z.string(),
+    import_by: optionalUuid,
+    import_time: optionalTimestamp,
+    closing_by: optionalUuid,
+    closing_time: optionalTimestamp,
+    gll_changed_flag: z.boolean().nullable().optional(),
+    version,
+    created_at: optionalTimestamp,
+    updated_at: optionalTimestamp,
+})
+    .passthrough();
+const closeCheckIssue = z
+    .object({
+    code: z.enum([
+        'PERIOD_ALREADY_CLOSED',
+        'BALANCE_RECALCULATION_REQUIRED',
+        'IMPORT_NOT_COMPLETED',
+        'BALANCE_MISSING',
+    ]),
+    message: z.string(),
+})
+    .passthrough();
+const revaluationIssue = z
+    .object({
+    code: z.enum([
+        'PERIOD_ALREADY_CLOSED',
+        'BALANCE_RECALCULATION_REQUIRED',
+        'IMPORT_NOT_COMPLETED',
+        'BALANCE_MISSING',
+        'NO_FOREIGN_CURRENCY_BALANCES',
+    ]),
+    message: z.string(),
+})
+    .passthrough();
+const closeCheckResponse = z
+    .object({
+    closing_status: z.enum(['OPEN', 'CLOSED']),
+    check_token: z.string().min(1),
+    checked_at: z.string(),
+    summary: z
+        .object({
+        ledger_code: z.string(),
+        balance_ok: z.boolean(),
+        unposted_journal_count: nonNegativeInteger,
+        exception_count: nonNegativeInteger,
+    })
+        .passthrough(),
+    blockers: z.array(closeCheckIssue),
+    warnings: z.array(closeCheckIssue),
+})
+    .passthrough();
+const revaluationPreviewResponse = z
+    .object({
+    period_name: z.string(),
+    foreign_currency_balance_count: nonNegativeInteger,
+    blockers: z.array(revaluationIssue),
+    warnings: z.array(revaluationIssue),
+})
+    .passthrough();
+const revaluationResponse = z
+    .object({
+    revaluation_status: z.string(),
+    foreign_currency_balance_count: nonNegativeInteger,
+})
+    .passthrough();
+const reconcileResponse = z
+    .object({
+    reconcile_status: z.string(),
+    journal_count: nonNegativeInteger,
+    balance_count: nonNegativeInteger,
+})
+    .passthrough();
+const depreciationRequest = bodyRequest(z.object({ ledger_id: uuidSchema, period_name: z.string() }).strict());
+const depreciationPreviewResponse = z
+    .object({
+    asset_count: nonNegativeInteger,
+    total_depr_amount: decimal,
+    lines: z.array(z.object({ asset_no: z.string(), amount: decimal }).passthrough()),
+    skipped: z.array(z
+        .object({
+        finance_id: uuidSchema,
+        reason: z.enum([
+            'ASSET_TYPE_CIP',
+            'NOT_IN_EFFECT',
+            'DEPR_FLAG_OFF',
+            'PERIOD_CLOSED',
+        ]),
+        detail: optionalText,
+    })
+        .passthrough()),
+    locked_orgs: z.array(z
+        .object({
+        org_id: uuidSchema,
+        org_name: z.string(),
+        affected_card_count: nonNegativeInteger,
+        closed_ledgers: z.array(z
+            .object({ ledger_code: z.string(), ledger_name: z.string() })
+            .passthrough()),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const depreciationRunResponse = z
+    .object({
+    asset_count: nonNegativeInteger,
+    total_depr_amount: decimal,
+    period_name: z.string(),
+})
+    .passthrough();
+const costContextResponse = z
+    .object({
+    asset_finance_id: uuidSchema,
+    current_cost: decimal,
+    is_cost_posted: z.boolean(),
+    will_create_adjust: z.boolean(),
+    open_period_name: z.string(),
+    version,
+})
+    .passthrough();
+const costAdjustResponse = z
+    .object({
+    adjust_amount: decimal,
+    source_detail_id: uuidSchema,
+    period_name: z.string(),
+    current_cost: decimal,
+    accum_depr: decimal,
+    nbv: decimal,
+    version,
+})
+    .passthrough();
+const assetContextResponse = z
+    .object({
+    finance_id: uuidSchema,
+    card_id: uuidSchema,
+    asset_no: z.string(),
+    ledger_id: uuidSchema,
+    total_quantity: decimal,
+    existing_qty: decimal,
+    current_cost: decimal,
+    accum_depr: decimal,
+    accum_impair: decimal,
+    accum_retire: decimal,
+    impair_limit: decimal,
+})
+    .passthrough();
+const impairmentResponse = z
+    .object({
+    depr_detail_id: uuidSchema,
+    movement_type: z.literal('IMPAIR'),
+    amount: decimal,
+})
+    .passthrough();
+const retirementResponse = z
+    .object({
+    depr_detail_id: uuidSchema,
+    movement_type: z.literal('RETIRE'),
+    amount: decimal,
+    quantity: decimal,
+})
+    .passthrough();
+const eventListItem = z
+    .object({
+    event_id: uuidSchema,
+    entry_source: z.string(),
+    event_no: z.string(),
+    event_time: z.string(),
+    event_type: z.string(),
+    business_type: optionalText,
+    strategy_key: optionalText,
+    description: optionalText,
+    is_backfill: z.boolean(),
+    crypto_count: nonNegativeInteger,
+    fiat_count: nonNegativeInteger,
+    security_count: nonNegativeInteger,
+    derivative_count: nonNegativeInteger,
+    ar_count: nonNegativeInteger,
+    ap_count: nonNegativeInteger,
+    tx_count: nonNegativeInteger,
+})
+    .passthrough();
+const eventLine = z
+    .object({
+    source_key: z.string(),
+    source_type: z.string(),
+    line_id: uuidSchema,
+    flow_type: optionalText,
+    system_type: optionalText,
+    biz_types: z.array(z
+        .object({
+        slot: z.string(),
+        name: z.string().nullable(),
+        value: z.string(),
+    })
+        .passthrough()),
+    attributes: z.array(z
+        .object({
+        slot: z.string(),
+        name: z.string().nullable(),
+        value: z.string(),
+    })
+        .passthrough()),
+    from_party: optionalText,
+    to_party: optionalText,
+    biz_date: optionalTimestamp,
+    sub_account_id: optionalUuid,
+    main_account_id: optionalUuid,
+    main_account_name: optionalText,
+    symbol: optionalText,
+    quantity: optionalDecimal,
+    base_rate: optionalDecimal,
+    base_amount: optionalDecimal,
+    base_currency: optionalText,
+    base_rate_time: optionalTimestamp,
+    ledger_id: optionalUuid,
+    coa_code: optionalText,
+    description: optionalText,
+    reference: optionalText,
+    version: version.nullable().optional(),
+    resolved: z.boolean(),
+})
+    .passthrough();
+const eventCheckResponse = z
+    .object({
+    warn_count: nonNegativeInteger,
+    error_count: nonNegativeInteger,
+    warn_groups: z.array(z
+        .object({
+        source_type: z.string(),
+        line_id: uuidSchema,
+        ledger_id: uuidSchema,
+        event_cnt: nonNegativeInteger,
+        event_ids: z.array(uuidSchema),
+    })
+        .passthrough()),
+    block_rows: z.array(z
+        .object({
+        source_type: z.string(),
+        line_id: uuidSchema,
+        ledger_id: uuidSchema,
+    })
+        .passthrough()),
+})
+    .passthrough();
+export const sourceTypesUpstreamSchema = z
+    .object({
+    source_types: z.array(z
+        .object({ source_type: z.string(), has_enabled_chain: z.boolean() })
+        .passthrough()),
+})
+    .passthrough();
+const collectResponse = z
+    .object({
+    result: z
+        .object({
+        input_tx_count: nonNegativeInteger,
+        output_event_count: nonNegativeInteger,
+    })
+        .passthrough(),
+    success_count: nonNegativeInteger,
+    failed_count: nonNegativeInteger,
+    deleted_event_count: nonNegativeInteger,
+    failed: z.array(z.object({ source_id: uuidSchema, reason: z.string() }).passthrough()),
+    degraded: z.array(z.object({ source_id: uuidSchema, reason: z.string() }).passthrough()),
+})
+    .passthrough();
+const poll = z
+    .object({
+    run_kind: z.enum(['RUL_LOOP', 'EVENT_COLLECT', 'PNL_CALC']),
+    native_status: z.string(),
+    running: z.boolean(),
+    done: z.boolean(),
+    failed: z.boolean(),
+    incomplete: z.boolean(),
+    terminal: z.boolean(),
+    failure_reason: z
+        .object({ error_code: z.string(), message: optionalText })
+        .passthrough()
+        .nullable(),
+})
+    .passthrough();
+const autoFlowItem = z
+    .object({
+    id: uuidSchema,
+    org_id: uuidSchema,
+    current_step: z.string(),
+    loop_status: z.enum(['PENDING', 'RUNNING', 'SUCCESS', 'FAILED', 'BLOCKED']),
+    loop_count: nonNegativeInteger,
+    loop_start_time: optionalTimestamp,
+    loop_end_time: optionalTimestamp,
+    event_collect_mode: z.string(),
+    fifo_mode: z.string(),
+})
+    .passthrough();
+export const autoFlowDetailUpstreamSchema = z
+    .object({
+    flow: autoFlowItem,
+    loop_seq: nonNegativeInteger,
+    steps: z.array(z
+        .object({
+        id: uuidSchema,
+        loop_seq: nonNegativeInteger,
+        step_code: z.string(),
+        step_order: nonNegativeInteger,
+        status: z.string(),
+        input_count: nonNegativeInteger,
+        output_count: nonNegativeInteger,
+        error_count: nonNegativeInteger,
+    })
+        .passthrough()),
+    loops: z.array(z
+        .object({
+        loop_seq: nonNegativeInteger,
+        loop_status: z.string(),
+        loop_end_time: optionalTimestamp,
+    })
+        .passthrough()),
+    poll,
+})
+    .passthrough();
+const autoFlowRunResponse = z
+    .object({
+    flow_id: uuidSchema,
+    loop_seq: nonNegativeInteger,
+    loop_status: z.string(),
+    current_step: z.string(),
+    fifo_covered_until: optionalTimestamp,
+})
+    .passthrough();
+export const pnlRunUpstreamSchema = z
+    .object({
+    id: uuidSchema,
+    mode: z.enum(['FULL', 'INCREMENTAL', 'SCOPED']),
+    status: z.enum(['RUNNING', 'COMPLETED', 'FAILED']),
+    bucket_id: uuidSchema,
+    symbol: optionalText,
+    from_date: dateSchema,
+    to_date: dateSchema,
+    lines_processed: nonNegativeInteger,
+    ins_created: nonNegativeInteger,
+    outs_created: nonNegativeInteger,
+    transfers_created: nonNegativeInteger,
+    total_realized_gl: optionalDecimal,
+    error_message: optionalText,
+    started_at: optionalTimestamp,
+    completed_at: optionalTimestamp,
+    created_at: z.string(),
+    poll,
+})
+    .passthrough();
+const mappingAttributeDefinition = z
+    .object({
+    id: uuidSchema,
+    source_key: z.string(),
+    biz_type_no: integer.min(1).max(4),
+    attr_name: z.string(),
+    value_source: optionalText,
+    version,
+    created_at: z.string(),
+    updated_at: z.string(),
+})
+    .passthrough();
+const mappingAttributeFill = z
+    .object({
+    id: uuidSchema,
+    source_category: z.string(),
+    source_code: z.string(),
+    line_type: z.string(),
+    system_type: z.string(),
+    target_field: z.string(),
+    source_expr: z.string(),
+    note: optionalText,
+    is_system: z.boolean(),
+    version,
+    created_at: z.string(),
+    updated_at: z.string(),
+})
+    .passthrough();
+const mappingSourceHandler = z
+    .object({
+    id: uuidSchema,
+    source_category: z.string(),
+    source_code: z.string(),
+    source_table: z.string(),
+    target_line_types: z.string(),
+    handler_proc: z.string(),
+    priority: integer,
+    status: z.string(),
+    description: optionalText,
+    is_system: z.boolean(),
+    version,
+    created_at: z.string(),
+    updated_at: z.string(),
+})
+    .passthrough();
+const accountingRule = z
+    .object({
+    id: uuidSchema,
+    ledger_id: uuidSchema,
+    rule_code: z.string(),
+    rule_name: z.string(),
+    rule_description: optionalText,
+    priority: integer,
+    effective_from: z.string(),
+    effective_to: optionalTimestamp,
+    match_event_type_op: optionalText,
+    match_event_type_vals: z.array(z.string()),
+    match_strategy_key_op: optionalText,
+    match_strategy_key_vals: z.array(z.string()),
+    is_no_booking: z.boolean(),
+    is_merge_same_rule_line: z.boolean(),
+    is_merge_eligible: z.boolean(),
+    is_enabled: z.boolean(),
+    version,
+    created_at: z.string(),
+    updated_at: optionalTimestamp,
+})
+    .passthrough();
+const allocationConfigHead = z
+    .object({
+    id: uuidSchema,
+    ledger_id: uuidSchema,
+    ledger_name: z.string(),
+    coa_code: z.string(),
+    coa_name: z.string(),
+    attributes: z.array(z.string().nullable()),
+    description: optionalText,
+    reference: optionalText,
+    ratio_total: decimal,
+    enabled: z.boolean(),
+    line_count: nonNegativeInteger,
+    version,
+    created_at: z.string(),
+    updated_at: z.string(),
+})
+    .passthrough();
+const pnlBucket = z
+    .object({
+    id: uuidSchema,
+    org_id: uuidSchema,
+    bucket_code: z.string(),
+    bucket_name: z.string(),
+    cost_method: z.enum(['FIFO', 'LIFO', 'WA']),
+    reporting_currency: z.string(),
+    treat_crypto_swap_as_disposal: z.boolean(),
+    transfer_group: optionalText,
+    status: z.enum(['ACTIVE', 'DISABLED']),
+    member_count: nonNegativeInteger,
+    cost_method_locked: z.boolean(),
+    lock_version: version,
+    created_at: z.string(),
+    updated_at: z.string(),
+})
+    .passthrough();
+const generatorParameter = z
+    .object({
+    id: uuidSchema,
+    param_key: z.string(),
+    param_name: z.string(),
+    value_type: z.enum(['STRING', 'NUMBER', 'DATE', 'BOOLEAN']),
+    value: optionalText,
+    effective_date: dateSchema.nullable().optional(),
+    description: optionalText,
+    is_enabled: z.boolean(),
+    version,
+    created_at: z.string(),
+    updated_at: z.string(),
+})
+    .passthrough();
+const generatorRule = z
+    .object({
+    id: uuidSchema,
+    code: z.string(),
+    name: z.string(),
+    generator_type: z.string(),
+    formula: z.json(),
+    cron_expr: optionalText,
+    is_enabled: z.boolean(),
+    last_run_at: optionalTimestamp,
+    last_status: optionalText,
+    last_message: optionalText,
+    description: optionalText,
+    version,
+    created_at: z.string(),
+    updated_at: z.string(),
+})
+    .passthrough();
+const mappingAttributeDefinitionValues = z
+    .object({
+    source_key: z.string(),
+    biz_type_no: integer.min(1).max(4),
+    attr_name: z.string(),
+    value_source: z.string().optional(),
+})
+    .strict();
+const mappingAttributeDefinitionUpdateValues = z
+    .object({
+    attr_name: z.string().optional(),
+    value_source: z.string().optional(),
+})
+    .strict();
+const mappingAttributeFillValues = z
+    .object({
+    source_category: z.string(),
+    source_code: z.string(),
+    line_type: z.string(),
+    system_type: z.string(),
+    target_field: z.string(),
+    source_expr: z.string(),
+    note: z.string().optional(),
+})
+    .strict();
+const mappingAttributeFillUpdateValues = z
+    .object({ source_expr: z.string().optional(), note: z.string().optional() })
+    .strict();
+const mappingSourceHandlerValues = z
+    .object({
+    source_category: z.string(),
+    source_code: z.string(),
+    source_table: z.string(),
+    target_line_types: z.string(),
+    handler_proc: z.string(),
+    priority: integer.optional(),
+    status: z.string().optional(),
+    description: z.string().optional(),
+})
+    .strict();
+const mappingSourceHandlerUpdateValues = mappingSourceHandlerValues.omit({
+    source_category: true,
+    source_code: true,
+});
+const accountingRuleValues = z
+    .object({
+    ledger_id: uuidSchema,
+    rule_code: z.string(),
+    rule_name: z.string(),
+    rule_description: z.string().optional(),
+    priority: integer.optional(),
+    effective_from: z.string(),
+    effective_to: z.string().optional(),
+    match_event_type_op: z.string().optional(),
+    match_event_type_vals: z.array(z.string()).optional(),
+    match_strategy_key_op: z.string().optional(),
+    match_strategy_key_vals: z.array(z.string()).optional(),
+    is_no_booking: z.boolean().optional(),
+    is_merge_same_rule_line: z.boolean().optional(),
+    is_merge_eligible: z.boolean().optional(),
+    is_enabled: z.boolean().optional(),
+    remark: z.string().optional(),
+})
+    .strict();
+const accountingRuleUpdateValues = accountingRuleValues.omit({
+    ledger_id: true,
+    rule_code: true,
+});
+const allocationConfigValues = z
+    .object({
+    ledger_id: uuidSchema,
+    coa_code: z.string(),
+    attributes: z.array(z.string().nullable()).optional(),
+    description: z.string().optional(),
+    reference: z.string().optional(),
+    enabled: z.boolean().optional(),
+})
+    .strict();
+const allocationConfigUpdateValues = z
+    .object({
+    description: z.string().optional(),
+    reference: z.string().optional(),
+    enabled: z.boolean().optional(),
+})
+    .strict();
+const pnlBucketValues = z
+    .object({
+    bucket_code: z.string(),
+    bucket_name: z.string(),
+    cost_method: z.enum(['FIFO', 'LIFO', 'WA']),
+    reporting_currency: z.string(),
+    treat_crypto_swap_as_disposal: z.boolean().optional(),
+    transfer_group: z.string().optional(),
+    status: z.enum(['ACTIVE', 'DISABLED']).optional(),
+})
+    .strict();
+const generatorParameterValues = z
+    .object({
+    param_key: z.string(),
+    param_name: z.string(),
+    value_type: z.enum(['STRING', 'NUMBER', 'DATE', 'BOOLEAN']),
+    value: z.string().optional(),
+    effective_date: dateSchema.optional(),
+    description: z.string().optional(),
+    is_enabled: z.boolean().optional(),
+})
+    .strict();
+const generatorParameterUpdateValues = generatorParameterValues.omit({
+    param_key: true,
+});
+const generatorRuleValues = z
+    .object({
+    code: z.string(),
+    name: z.string(),
+    generator_type: z.string(),
+    formula: z.json(),
+    description: z.string().optional(),
+    is_enabled: z.boolean().optional(),
+})
+    .strict();
+const generatorRuleUpdateValues = generatorRuleValues.omit({ code: true });
+const allocationLine = z
+    .object({
+    id: uuidSchema,
+    line_no: nonNegativeInteger,
+    coa_code: z.string(),
+    coa_name: z.string(),
+    attributes: z.array(z.string().nullable()),
+    biz_types: z.array(z.string().nullable()),
+    description: optionalText,
+    reference: optionalText,
+    ratio: decimal,
+    enabled: z.boolean().optional(),
+    base_currency: optionalText,
+    base_amount: optionalDecimal,
+    origin_currency: optionalText,
+    origin_amount: optionalDecimal,
+})
+    .passthrough();
+const allocationConfigDetail = z
+    .object({ head: allocationConfigHead, lines: z.array(allocationLine) })
+    .passthrough();
+const crudContracts = {
+    map_attr_definition: {
+        entity: mappingAttributeDefinition,
+        createValues: mappingAttributeDefinitionValues,
+        updateValues: mappingAttributeDefinitionUpdateValues,
+    },
+    map_attribute_fill: {
+        entity: mappingAttributeFill,
+        createValues: mappingAttributeFillValues,
+        updateValues: mappingAttributeFillUpdateValues,
+    },
+    map_source_handler: {
+        entity: mappingSourceHandler,
+        createValues: mappingSourceHandlerValues,
+        updateValues: mappingSourceHandlerUpdateValues,
+    },
+    accounting_rule: {
+        entity: accountingRule,
+        createValues: accountingRuleValues,
+        updateValues: accountingRuleUpdateValues,
+        createResponse: z.object({ id: uuidSchema }).passthrough(),
+    },
+    allocation_config: {
+        entity: allocationConfigHead,
+        createValues: allocationConfigValues,
+        updateValues: allocationConfigUpdateValues,
+        detailResponse: allocationConfigDetail,
+        createResponse: z.object({ id: uuidSchema }).passthrough(),
+    },
+    pnl_bucket: {
+        entity: pnlBucket,
+        createValues: pnlBucketValues,
+        updateValues: pnlBucketValues,
+    },
+    generator_parameter: {
+        entity: generatorParameter,
+        createValues: generatorParameterValues,
+        updateValues: generatorParameterUpdateValues,
+    },
+    generator_rule: {
+        entity: generatorRule,
+        createValues: generatorRuleValues,
+        updateValues: generatorRuleUpdateValues,
+    },
+};
+const precheckValues = z
+    .object({
+    ledger_id: uuidSchema.optional(),
+    main_account_id: uuidSchema.optional(),
+    sub_account_id: uuidSchema.optional(),
+    config_level: z.enum(['MAIN_ACCOUNT', 'SUB_ACCOUNT']).optional(),
+    config_scope: z.enum(['MAIN', 'SUB']).optional(),
+    is_enabled: z.boolean().optional(),
+    effective_from: z.string().optional(),
+    effective_to: z.string().optional(),
+    match_from_address: z.string().optional(),
+    match_to_address: z.string().optional(),
+    match_from_party_id: uuidSchema.optional(),
+    match_to_party_id: uuidSchema.optional(),
+    match_system_type: z.string().optional(),
+    match_flow_type: z.string().optional(),
+    main_coa_code: z.string().optional(),
+    counter_coa_code: z.string().optional(),
+    main_description: z.string().optional(),
+    main_reference: z.string().optional(),
+    counter_description: z.string().optional(),
+    counter_reference: z.string().optional(),
+    remark: z.string().optional(),
+    ...Object.fromEntries(['main', 'counter'].flatMap((side) => Array.from({ length: 12 }, (_, index) => [
+        `${side}_attribute${index + 1}`,
+        z.string().nullable().optional(),
+    ]))),
+})
+    .strict();
+const precheckDetail = z
+    .object({
+    id: uuidSchema,
+    ledger_id: uuidSchema,
+    org_id: uuidSchema,
+    main_account_id: uuidSchema,
+    account_code: z.string(),
+    sub_account_id: optionalUuid,
+    sub_account_code: optionalText,
+    config_level: z.enum(['MAIN_ACCOUNT', 'SUB_ACCOUNT']),
+    config_scope: z.enum(['MAIN', 'SUB']),
+    is_enabled: z.boolean(),
+    effective_from: optionalTimestamp,
+    effective_to: optionalTimestamp,
+    match_from_address: optionalText,
+    match_to_address: optionalText,
+    match_from_party_id: optionalUuid,
+    match_to_party_id: optionalUuid,
+    match_system_type: optionalText,
+    match_flow_type: optionalText,
+    main_coa_code: optionalText,
+    main_coa_name: optionalText,
+    counter_coa_code: optionalText,
+    counter_coa_name: optionalText,
+    is_ready: z.boolean(),
+    ready_status: z.string(),
+    ready_reason: optionalText,
+    remark: optionalText,
+    ...Object.fromEntries(['main', 'counter'].flatMap((side) => Array.from({ length: 12 }, (_, index) => [
+        `${side}_attribute${index + 1}`,
+        z.string().nullable().optional(),
+    ]))),
+    version,
+})
+    .passthrough();
+const precheckTreeRow = z
+    .object({
+    id: uuidSchema,
+    config_scope: z.enum(['MAIN', 'SUB']),
+    ready_status: z.string(),
+    is_ready: z.boolean(),
+    ready_reason: optionalText,
+    is_enabled: z.boolean(),
+    effective_from: optionalTimestamp,
+    effective_to: optionalTimestamp,
+    main_coa_code: optionalText,
+    main_coa_name: optionalText,
+    counter_coa_code: optionalText,
+    sub_account_id: optionalUuid,
+    sub_account_code: optionalText,
+    sub_account_name: optionalText,
+    version,
+})
+    .passthrough();
+const precheckTree = z.array(z
+    .object({
+    main_account_id: uuidSchema,
+    account_code: z.string(),
+    account_name: z.string(),
+    source_platform: optionalText,
+    config_level: z.string(),
+    main_row: precheckTreeRow.nullable(),
+    children: z.array(precheckTreeRow),
+})
+    .passthrough());
+const allocationResultHead = z
+    .object({
+    id: uuidSchema,
+    ledger_id: uuidSchema,
+    ledger_name: z.string(),
+    journal_id: uuidSchema,
+    journal_number: z.string(),
+    period_name: z.string(),
+    gl_date: dateSchema,
+    coa_code: z.string(),
+    coa_name: z.string(),
+    attributes: z.array(z.string().nullable()),
+    description: optionalText,
+    reference: optionalText,
+    gen_mode: z.string(),
+    status: z.string(),
+    line_count: nonNegativeInteger,
+    base_currency: z.string(),
+    net_base_amount: decimal,
+    version,
+    created_at: z.string(),
+})
+    .passthrough();
+const allocationResultDetail = z
+    .object({
+    head: allocationResultHead,
+    lines: z.array(allocationLine),
+})
+    .passthrough();
+const allocationSummary = z
+    .object({
+    rows: z.array(z
+        .object({
+        coa_code: z.string(),
+        coa_name: z.string(),
+        att_combo: z.string(),
+        total_base_amount: decimal,
+        line_count: nonNegativeInteger,
+    })
+        .passthrough()),
+    grand_total: decimal,
+})
+    .passthrough();
+export const extendedQueryResponseSchemas = {
+    'suite.acct.closing.list': page(closingView),
+    'suite.acct.closing.detail': closingView,
+    'suite.rul.events.list': page(eventListItem),
+    'suite.rul.events.lines': z.array(eventLine),
+    'suite.rul.events.check': eventCheckResponse,
+    'suite.config.map_attr_definition.list': page(mappingAttributeDefinition),
+    'suite.config.map_attr_definition.detail': mappingAttributeDefinition,
+    'suite.config.map_attribute_fill.list': page(mappingAttributeFill),
+    'suite.config.map_attribute_fill.detail': mappingAttributeFill,
+    'suite.config.map_source_handler.list': page(mappingSourceHandler),
+    'suite.config.map_source_handler.detail': mappingSourceHandler,
+    'suite.config.accounting_rule.list': page(accountingRule),
+    'suite.config.accounting_rule.detail': accountingRule,
+    'suite.config.precheck_rule.tree': precheckTree,
+    'suite.config.precheck_rule.detail': precheckDetail,
+    'suite.config.allocation_config.list': page(allocationConfigHead),
+    'suite.config.allocation_config.detail': allocationConfigDetail,
+    'suite.aloc.detail.list': page(allocationResultHead),
+    'suite.aloc.detail.detail': allocationResultDetail,
+    'suite.aloc.detail.summary': allocationSummary,
+};
+export function parseExtendedQueryResponse(capabilityId, response) {
+    return extendedQueryResponseSchemas[capabilityId].parse(response);
+}
+const allocationPreview = z
+    .object({
+    journal_number: z.string(),
+    hit: z.boolean(),
+    lines: z.array(z
+        .object({
+        src_line_no: nonNegativeInteger,
+        coa_code: z.string(),
+        net_base: decimal,
+        expanded: z.array(z
+            .object({
+            ratio: decimal,
+            coa_code: z.string(),
+            base_amount: decimal,
+        })
+            .passthrough()),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const allocationGenerate = z
+    .object({
+    hit: z.boolean(),
+    head_ids: z.array(uuidSchema),
+    already_exists_count: nonNegativeInteger,
+    line_count: nonNegativeInteger,
+    total_base_amount: decimal,
+})
+    .passthrough();
+const allocationLinesRequest = z
+    .object({
+    object_id: uuidSchema,
+    version,
+    lines: z
+        .array(z.object({ line_no: integer.positive(), ratio: decimal }).passthrough())
+        .min(1),
+})
+    .strict();
+const allocationLinesResponse = z
+    .object({
+    cfg_head_id: uuidSchema,
+    version,
+    ratio_total: decimal,
+    line_count: nonNegativeInteger,
+})
+    .passthrough();
+const pnlMemberResponse = z
+    .object({
+    id: uuidSchema,
+    bucket_id: uuidSchema,
+    sub_account_id: uuidSchema,
+    joined_at: dateSchema,
+    active: z.boolean(),
+    lock_version: version,
+})
+    .passthrough();
+const generatorRunResponse = z
+    .object({
+    success: z.boolean(),
+    created_count: nonNegativeInteger,
+    status: z.string(),
+    message: optionalText,
+})
+    .passthrough();
+const contracts = new Map();
+function register(ids, request, response) {
+    for (const id of typeof ids === 'string' ? [ids] : ids) {
+        if (contracts.has(id))
+            throw new Error(`Duplicate extended capability contract: ${id}`);
+        contracts.set(id, {
+            request,
+            response,
+        });
+    }
+}
+register('suite.acct.journal.verify_submit', z.object({ journal_id: uuidSchema, version }).strict(), journalVerifyAndSubmitResponse);
+register('suite.acct.journal.batch_submit', z.object({ journal_ids: z.array(uuidSchema).min(2) }).strict(), batchSubmitResponse);
+for (const document of ['ap.payable', 'ar.receivable']) {
+    register(`suite.${document}.verify_submit`, z.object({ document_id: uuidSchema, version }).strict(), verifyAndSubmitResponse);
+    register(`suite.${document}.post`, idRequest('document_id'), documentPostResponse);
+    register([
+        `suite.${document}.offset_candidates`,
+        `suite.${document}.internal_offset_candidates`,
+    ], idRequest('document_id'), offsetCandidatesResponse);
+    register(`suite.${document}.offset_apply`, idBodyRequest('document_id', offsetBody), offsetApplyResponse);
+}
+register('suite.acct.closing.list', queryRequest, extendedQueryResponseSchemas['suite.acct.closing.list']);
+register('suite.acct.closing.detail', idRequest('closing_id'), extendedQueryResponseSchemas['suite.acct.closing.detail']);
+register('suite.acct.closing.revaluation_preview', z.object({ closing_id: uuidSchema, version }).strict(), revaluationPreviewResponse);
+register('suite.acct.closing.revaluation_confirm', z.object({ closing_id: uuidSchema, version }).strict(), revaluationResponse);
+register('suite.acct.closing.close_check', z.object({ closing_id: uuidSchema, version }).strict(), closeCheckResponse);
+register('suite.acct.closing.close_book', z
+    .object({
+    closing_id: uuidSchema,
+    version,
+    check_token: z.string().min(1),
+    close_reason: z.string().optional(),
+})
+    .strict(), closingView);
+register('suite.acct.closing.reconcile', z
+    .object({ closing_id: uuidSchema, version, note: z.string().optional() })
+    .strict(), reconcileResponse);
+register('suite.acct.closing.reverse', z.object({ closing_id: uuidSchema, version, reason: z.string() }).strict(), closingView);
+register('suite.fa.depreciation.preview', depreciationRequest, depreciationPreviewResponse);
+register('suite.fa.depreciation.run', depreciationRequest, depreciationRunResponse);
+register('suite.fa.cost_adjust.context', idRequest('finance_id'), costContextResponse);
+register('suite.fa.cost_adjust.submit', idBodyRequest('finance_id', z
+    .object({ new_cost: decimal, version, remark: z.string().optional() })
+    .strict()), costAdjustResponse);
+register('suite.fa.impair_retire.context', idRequest('finance_id'), assetContextResponse);
+register('suite.fa.impair.submit', idBodyRequest('finance_id', z
+    .object({
+    biz_date: dateSchema,
+    this_amount: decimal,
+    remark: z.string().optional(),
+})
+    .strict()), impairmentResponse);
+register('suite.fa.retire.submit', idBodyRequest('finance_id', z
+    .object({
+    biz_date: dateSchema,
+    retire_qty: decimal,
+    this_amount: decimal.optional(),
+    remark: z.string().optional(),
+})
+    .strict()), retirementResponse);
+register('suite.rul.events.list', queryRequest, extendedQueryResponseSchemas['suite.rul.events.list']);
+register('suite.rul.events.lines', idRequest('event_id'), extendedQueryResponseSchemas['suite.rul.events.lines']);
+register('suite.rul.events.check', queryRequest, extendedQueryResponseSchemas['suite.rul.events.check']);
+register('suite.rul.events.source_types', z.object({}).strict(), sourceTypesUpstreamSchema);
+register('suite.rul.events.collect_by_ids', bodyRequest(z
+    .object({
+    org_id: uuidSchema,
+    source_type: z.string(),
+    source_ids: z.array(uuidSchema).min(1).max(1000),
+    strategy_keys: z.array(z.string()).min(1).optional(),
+})
+    .strict()), collectResponse);
+register('suite.rul.auto_flow.detail', z
+    .object({ flow_id: uuidSchema, loop_seq: nonNegativeInteger.optional() })
+    .strict(), autoFlowDetailUpstreamSchema);
+register('suite.rul.auto_flow.run', idRequest('flow_id'), autoFlowRunResponse);
+for (const [key, contract] of Object.entries(crudContracts)) {
+    const listCapabilityId = `suite.config.${key}.list`;
+    const detailCapabilityId = `suite.config.${key}.detail`;
+    register(listCapabilityId, queryRequest, listCapabilityId in extendedQueryResponseSchemas
+        ? extendedQueryResponseSchemas[listCapabilityId]
+        : page(contract.entity));
+    register(detailCapabilityId, idRequest('object_id'), detailCapabilityId in extendedQueryResponseSchemas
+        ? extendedQueryResponseSchemas[detailCapabilityId]
+        : (contract.detailResponse ?? contract.entity));
+    register(`suite.config.${key}.create`, z.object({ values: contract.createValues }).strict(), contract.createResponse ?? contract.entity);
+    register(`suite.config.${key}.update`, z
+        .object({ object_id: uuidSchema, version, values: contract.updateValues })
+        .strict(), contract.updateResponse ?? contract.entity);
+}
+register('suite.config.precheck_rule.tree', queryRequest, extendedQueryResponseSchemas['suite.config.precheck_rule.tree']);
+register('suite.config.precheck_rule.detail', idRequest('object_id'), extendedQueryResponseSchemas['suite.config.precheck_rule.detail']);
+register('suite.config.precheck_rule.create', z.object({ values: precheckValues }).strict(), z.object({ id: uuidSchema, ready_status: z.string() }).passthrough());
+register('suite.config.precheck_rule.update', z.object({ object_id: uuidSchema, version, values: precheckValues }).strict(), precheckDetail);
+register('suite.aloc.detail.list', queryRequest, extendedQueryResponseSchemas['suite.aloc.detail.list']);
+register('suite.aloc.detail.detail', idRequest('object_id'), extendedQueryResponseSchemas['suite.aloc.detail.detail']);
+register('suite.aloc.detail.summary', queryRequest, extendedQueryResponseSchemas['suite.aloc.detail.summary']);
+register('suite.config.allocation_config.lines', allocationLinesRequest, allocationLinesResponse);
+register('suite.aloc.generate.preview', idRequest('journal_id'), allocationPreview);
+register('suite.aloc.generate.execute', idRequest('journal_id'), allocationGenerate);
+register('suite.pnl.calculation.run', bodyRequest(z
+    .object({
+    mode: z.enum(['FULL', 'INCREMENTAL', 'SCOPED']),
+    bucket_id: uuidSchema,
+    symbol: z.string().optional(),
+    from_date: dateSchema,
+    to_date: dateSchema,
+})
+    .strict()), pnlRunUpstreamSchema);
+register('suite.pnl.calculation.status', idRequest('run_id'), pnlRunUpstreamSchema);
+register('suite.config.pnl_bucket.member_add', z
+    .object({
+    bucket_id: uuidSchema,
+    values: z
+        .object({ sub_account_id: uuidSchema, joined_at: dateSchema })
+        .strict(),
+})
+    .strict(), pnlMemberResponse);
+register('suite.pgen.rule.run', z
+    .object({ rule_id: uuidSchema, business_date: dateSchema.optional() })
+    .strict(), generatorRunResponse);
+export function getExtendedOperationContract(capabilityId) {
+    const contract = contracts.get(capabilityId);
+    if (contract === undefined) {
+        throw new Error(`Missing extended capability contract: ${capabilityId}`);
+    }
+    return contract;
+}
+export function extendedOperationContractIds() {
+    return [...contracts.keys()].sort();
+}
+//# sourceMappingURL=extended-operation-contracts.js.map