wowok_agent 1.6.6 → 2.1.9

package/dist/schema/call/handler.d.ts

@@ -0,0 +1,80 @@
+import type { CallEnv } from "wowok";
+import type { CallOutput } from "./base.js";
+/**
+ * Process Call result and return unified MCP output format
+ * @param result Call operation result
+ * @returns Unified MCP output format
+ */
+export declare function handleCallResult(result: any): {
+    content: any[];
+    structuredContent: CallOutput;
+};
+/**
+ * Create standard MCP Server configuration
+ * @param packageJson package.json content
+ * @returns MCP Server configuration
+ */
+export declare function createServerConfig(packageJson: any): {
+    name: any;
+    version: any;
+    description: any;
+};
+/**
+ * Create MCP Server capabilities configuration
+ * @returns Capabilities configuration
+ */
+export declare function createCapabilitiesConfig(): {
+    capabilities: {
+        prompts: {};
+        resources: {};
+        tools: {
+            listChanged: boolean;
+        };
+        logging: {};
+    };
+};
+/**
+ * Create standard tool metadata
+ * @param category Tool category
+ * @param tags Tool tags
+ * @returns Tool metadata
+ */
+export declare function createToolMeta(category: string, tags: string[]): {
+    author: string;
+    createdAt: string;
+    lastUpdated: string;
+    category: string;
+    tags: string[];
+    requiresAuth: boolean;
+};
+/**
+ * Create standard tool annotations
+ * @param readOnlyHint Whether read-only
+ * @param destructiveHint Whether destructive
+ * @returns Tool annotations
+ */
+export declare function createToolAnnotations(readOnlyHint?: boolean, destructiveHint?: boolean): {
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    idempotentHint: boolean;
+    openWorldHint: boolean;
+};
+/**
+ * Process submission parameter transformation
+ * @param submission submission parameter
+ * @returns Transformed submission parameter
+ */
+export declare function transformSubmission(submission: any): any;
+/**
+ * Validate input data
+ * @param data Input data
+ * @param schema Zod schema
+ * @returns Validated data
+ */
+export declare function validateInput<T>(data: any, schema: any): T;
+/**
+ * Get environment configuration
+ * @param env Environment parameters
+ * @returns Environment configuration
+ */
+export declare function getEnvConfig(env?: any): CallEnv;

package/dist/schema/call/handler.js

@@ -0,0 +1,177 @@
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+import { ResponseData } from "wowok";
+/**
+ * Process Call result and return unified MCP output format
+ * @param result Call operation result
+ * @returns Unified MCP output format
+ */
+export function handleCallResult(result) {
+    // Handle error result
+    if (result && "error" in result) {
+        const output = {
+            message: `Error: ${result.error}`,
+            result: { type: "error", error: result.error },
+        };
+        return {
+            content: [{ type: "text", text: output.message }],
+            structuredContent: output,
+        };
+    }
+    // Handle transaction result (contains digest field)
+    if (result && "digest" in result) {
+        const r = ResponseData(result);
+        const output = {
+            message: "Transaction completed successfully",
+            result: { type: "transaction", ...result },
+        };
+        return {
+            content: [
+                { type: "text", text: output.message },
+                { type: "text", text: JSON.stringify(r) },
+            ],
+            structuredContent: output,
+        };
+    }
+    // Handle submission result (contains guard and submission fields)
+    if (result && "guard" in result && "submission" in result) {
+        const output = {
+            message: "Submission required for Guard verification",
+            result: { type: "submission", ...result },
+        };
+        return {
+            content: [
+                { type: "text", text: output.message },
+                { type: "text", text: JSON.stringify(result) },
+            ],
+            structuredContent: output,
+        };
+    }
+    // Handle array result
+    if (Array.isArray(result)) {
+        const output = {
+            message: "Operation completed",
+            result: { type: "data", data: result },
+        };
+        return {
+            content: [
+                { type: "text", text: output.message },
+                { type: "text", text: JSON.stringify(result) },
+            ],
+            structuredContent: output,
+        };
+    }
+    // Handle empty or null result
+    if (result === undefined || result === null) {
+        const output = {
+            message: "Operation completed",
+            result: { type: "null" },
+        };
+        return {
+            content: [{ type: "text", text: output.message }],
+            structuredContent: output,
+        };
+    }
+    // Default handling for other result types - treat as transaction
+    const output = {
+        message: "Operation completed",
+        result: { type: "transaction", ...result },
+    };
+    return {
+        content: [{ type: "text", text: output.message }],
+        structuredContent: output,
+    };
+}
+/**
+ * Create standard MCP Server configuration
+ * @param packageJson package.json content
+ * @returns MCP Server configuration
+ */
+export function createServerConfig(packageJson) {
+    return {
+        name: packageJson.name,
+        version: packageJson.version,
+        description: packageJson.description,
+    };
+}
+/**
+ * Create MCP Server capabilities configuration
+ * @returns Capabilities configuration
+ */
+export function createCapabilitiesConfig() {
+    return {
+        capabilities: {
+            prompts: {},
+            resources: {},
+            tools: { listChanged: true },
+            logging: {},
+        },
+    };
+}
+/**
+ * Create standard tool metadata
+ * @param category Tool category
+ * @param tags Tool tags
+ * @returns Tool metadata
+ */
+export function createToolMeta(category, tags) {
+    return {
+        author: "WOWOK Team",
+        createdAt: "2026-02-01",
+        lastUpdated: "2026-02-01",
+        category,
+        tags,
+        requiresAuth: false,
+    };
+}
+/**
+ * Create standard tool annotations
+ * @param readOnlyHint Whether read-only
+ * @param destructiveHint Whether destructive
+ * @returns Tool annotations
+ */
+export function createToolAnnotations(readOnlyHint = false, destructiveHint = false) {
+    return {
+        readOnlyHint,
+        destructiveHint,
+        idempotentHint: true,
+        openWorldHint: false,
+    };
+}
+/**
+ * Process submission parameter transformation
+ * @param submission submission parameter
+ * @returns Transformed submission parameter
+ */
+export function transformSubmission(submission) {
+    if (!submission)
+        return undefined;
+    return {
+        type: "submission",
+        guard: (submission.guard || []).map((g) => ({
+            object: g.object || "",
+            impack: g.impack || false,
+        })),
+        submission: (submission.submission || []).map((s) => ({
+            guard: s.guard || "",
+            submission: s.submission || [],
+        })),
+    };
+}
+/**
+ * Validate input data
+ * @param data Input data
+ * @param schema Zod schema
+ * @returns Validated data
+ */
+export function validateInput(data, schema) {
+    return schema.parse(data);
+}
+/**
+ * Get environment configuration
+ * @param env Environment parameters
+ * @returns Environment configuration
+ */
+export function getEnvConfig(env) {
+    return env || {};
+}

package/dist/schema/call/index.d.ts

@@ -0,0 +1,18 @@
+export * from './base.js';
+export * from './handler.js';
+export * from './contact.js';
+export * from './demand.js';
+export * from './guard.js';
+export * from './machine.js';
+export * from './arbitration.js';
+export * from './allocation.js';
+export * from './order.js';
+export * from './payment.js';
+export * from './permission.js';
+export * from './personal.js';
+export * from './proof.js';
+export * from './progress.js';
+export * from './repository.js';
+export * from './reward.js';
+export * from './service.js';
+export * from './treasury.js';

package/dist/schema/call/index.js

@@ -0,0 +1,19 @@
+// Export all schema definitions
+export * from './base.js';
+export * from './handler.js';
+export * from './contact.js';
+export * from './demand.js';
+export * from './guard.js';
+export * from './machine.js';
+export * from './arbitration.js';
+export * from './allocation.js';
+export * from './order.js';
+export * from './payment.js';
+export * from './permission.js';
+export * from './personal.js';
+export * from './proof.js';
+export * from './progress.js';
+export * from './repository.js';
+export * from './reward.js';
+export * from './service.js';
+export * from './treasury.js';

package/dist/schema/call/machine.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const ProgressNamedOperatorSchema: any;
+export declare const ProgressNewSchema: any;
+export declare const NodeAddForwardDataSchema: any;
+export declare const NodeRemoveForwardDataSchema: any;
+export declare const NodeRemovePriorNodeDataSchema: any;
+export declare const NodeSchema: any;
+export declare const NodeJsonOrMarkdownFileSchema: any;
+export declare const NodeFieldSchema: any;
+export declare const CallMachine_DataSchema: any;
+export declare const CallMachine_InputSchema: any;
+export declare const MachineNode2File_InputSchema: any;
+export declare const MachineNode2File_OutputSchema: any;
+export declare const MachineNode2File_OutputWrappedSchema: any;
+export type CallMachine_Data = z.infer<typeof CallMachine_DataSchema>;
+export type ProgressNew = z.infer<typeof ProgressNewSchema>;
+export type ProgressNamedOperator = z.infer<typeof ProgressNamedOperatorSchema>;
+export type Node = z.infer<typeof NodeSchema>;
+export type NodeJsonOrMarkdownFile = z.infer<typeof NodeJsonOrMarkdownFileSchema>;
+export type NodeField = z.infer<typeof NodeFieldSchema>;
+export type MachineNode2File_Input = z.infer<typeof MachineNode2File_InputSchema>;
+export type MachineNode2File_Output = z.infer<typeof MachineNode2File_OutputSchema>;
+export type MachineNode2File_OutputWrapped = z.infer<typeof MachineNode2File_OutputWrappedSchema>;

package/dist/schema/call/machine.js

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+import { WithPermissionObjectSchema, NamedObjectSchema, ObjectsSchema, CallEnvSchema, SubmissionCallSchema, } from './base.js';
+import { MachineNodeSchema, PermissionIndexTypeSchema } from '../query/index.js';
+import { ManyAccountOrMark_AddressSchema, NameOrAddressSchema, NameSchema, NotEmptyNameSchema, ReceivedObjectsOrRecentlySchema } from '../common/index.js';
+// progress_new的progress_namedOperator字段类型
+export const ProgressNamedOperatorSchema = z.object({
+    op: z.union([z.literal('add'), z.literal('set'), z.literal('remove')]),
+    name: NotEmptyNameSchema,
+    operators: ManyAccountOrMark_AddressSchema,
+}).strict();
+// progress_new字段类型
+export const ProgressNewSchema = z.object({
+    task: z.union([NameOrAddressSchema, z.null()]).optional().describe('Task bound to the Progress object. It is an object ID or name'),
+    repository: ObjectsSchema.optional().describe('Set repository list for the Progress object. Used for consensus data management.'),
+    progress_namedOperator: ProgressNamedOperatorSchema.optional().describe('Add, set, and remove operators for the permission namespace of the Progress object.'),
+    namedNew: NamedObjectSchema.optional(),
+}).strict();
+// node字段的add forward类型
+export const NodeAddForwardDataSchema = z.object({
+    prior_node_name: NameSchema.describe('Name of the previous node.'),
+    node_name: NameSchema.describe('Name of the next node.'),
+    forward: z.array(z.object({
+        name: NameSchema.describe('Name of the operation'),
+        namedOperator: z.union([NotEmptyNameSchema, z.null()]).optional().describe('One of the operation permissions: use operators within the permission space name in the Machine object. Each Progress object can manage operators independently.'),
+        permissionIndex: z.union([PermissionIndexTypeSchema, z.null()]).optional().describe('Second operation permission: use operators specified by the permission index of the Permission object in the Machine object. All Progress objects share the same operators.'),
+        weight: z.number().min(0).max(65535).int().describe('Weight of the operation'),
+    }).strict()).describe('List of operations between the previous and next nodes.'),
+    threshold: z.union([z.number().int().min(0), z.null()]).optional().describe('Threshold of operations that need to be completed to migrate from the previous node to the next node.'),
+}).strict();
+// node字段的remove forward类型
+export const NodeRemoveForwardDataSchema = z.object({
+    prior_node_name: NameSchema.describe('Name of the previous node.'),
+    node_name: NameSchema.describe('Name of the next node.'),
+    forward_name: z.array(NameSchema).describe('List of operation names to delete.'),
+}).strict();
+// node字段的remove prior node类型
+export const NodeRemovePriorNodeDataSchema = z.object({
+    prior_node_name: z.array(NameSchema).describe('List of previous node names to delete.'),
+    node_name: NameSchema.describe('Name of the next node.'),
+}).strict();
+// node字段类型
+export const NodeSchema = z.discriminatedUnion('op', [
+    z.object({
+        op: z.literal('add'),
+        nodes: z.array(MachineNodeSchema).describe('List of nodes to add or set.'),
+        bReplace: z.boolean().optional().describe('Whether to replace existing nodes. If true, existing nodes will be replaced; if false, nodes will be added by merging.'),
+    }).strict().describe('Add nodes.'),
+    z.object({
+        op: z.literal('set'),
+        nodes: z.array(MachineNodeSchema).describe('List of nodes to add or set.'),
+        bReplace: z.boolean().optional().describe('Whether to replace existing nodes. If true, existing nodes will be replaced; if false, nodes will be added by merging.'),
+    }).strict().describe('Set nodes.'),
+    z.object({
+        op: z.literal('remove'),
+        nodes: z.array(NameSchema).describe('List of node names to delete.'),
+    }).strict().describe('Delete nodes.'),
+    z.object({
+        op: z.literal('clear'),
+    }).strict().describe('Clear all nodes.'),
+    z.object({
+        op: z.literal('exchange'),
+        node_one: NameSchema.describe('Name of the first node.'),
+        node_other: NameSchema.describe('Name of the second node.'),
+    }).strict().describe('Exchange the positions of two nodes.'),
+    z.object({
+        op: z.literal('rename'),
+        node_name_old: NameSchema.describe('Name of thenode.'),
+        node_name_new: NameSchema.describe('New name of the node.'),
+    }).strict().describe('Rename node.'),
+    z.object({
+        op: z.literal('remove prior node'),
+        pairs: z.array(NodeRemovePriorNodeDataSchema).describe('List of previous-next node pairs to delete.'),
+    }).strict().describe('Delete previous-next node pairs.'),
+    z.object({
+        op: z.literal('add forward'),
+        data: z.array(NodeAddForwardDataSchema).describe('List of operations to add.'),
+    }).strict().describe('Add operations.'),
+    z.object({
+        op: z.literal('remove forward'),
+        data: z.array(NodeRemoveForwardDataSchema).describe('List of operations to delete.'),
+    }).strict().describe('Delete operations.'),
+]);
+// json_or_markdown_file 模式：从文件读取并完全替换节点定义
+export const NodeJsonOrMarkdownFileSchema = z.object({
+    json_or_markdown_file: z.string().describe(`Path to a JSON or Markdown file containing node array for COMPLETE REPLACEMENT of all nodes.
+
+**File Format Requirements:**
+- Must contain a JSON ARRAY of node objects: [{"name": "...", "pairs": [...]}, {...}]
+- NOT an operation object with "op" field (use NodeSchema for operations)
+- Supports JSON or Markdown (with \`\`\`json code blocks)
+
+**Node Structure:**
+Each node is a directed graph element representing workflow states and transitions:
+- name: Node identifier
+- pairs: Array of {prior_node, forwards, threshold} defining connections
+- forwards: Operations available from this node
+- threshold: Required weight to advance
+
+**Behavior:**
+- COMPLETELY REPLACES all existing nodes (equivalent to "set" with bReplace=true)
+- Auto-detects format based on file content
+- If parsing fails, error includes line number and column information`),
+}).strict();
+// node 字段支持两种模式
+export const NodeFieldSchema = z.union([
+    NodeSchema,
+    NodeJsonOrMarkdownFileSchema,
+]);
+// CallMachine_Data类型
+export const CallMachine_DataSchema = z.object({
+    object: WithPermissionObjectSchema,
+    progress_new: ProgressNewSchema.optional().describe('Generate new Progress object.'),
+    description: z.string().optional().describe('Description of the object.'),
+    repository: ObjectsSchema.optional().describe('Set repository list for the object. Used for consensus data management.'),
+    node: NodeFieldSchema.optional().describe(`CRITICAL: Choose ONE of two mutually exclusive modes:
+
+**Mode 1: NodeSchema (incremental operations)**
+Use for partial modifications: add, set, remove, clear, exchange, rename, remove prior node, add forward, remove forward.
+Format: { "op": "add", "nodes": [...], "bReplace": false }
+This mode modifies existing nodes incrementally.
+
+**Mode 2: NodeJsonOrMarkdownFileSchema (complete replacement)**
+Use for complete node redefinition from file.
+Format: { "json_or_markdown_file": "/path/to/nodes.json" }
+IMPORTANT: This COMPLETELY REPLACES all existing nodes. File must contain node array [{...}, {...}], NOT an operation object with "op" field.
+Supported formats: JSON array or Markdown with code blocks.
+If parsing fails, error includes line number and column information.`),
+    pause: z.boolean().optional().describe('Whether to pause generating new Progress objects.'),
+    publish: z.boolean().optional().describe('Whether to publish the object. After the object is published, new Progress objects can be generated; and node settings will no longer be changeable.'),
+    owner_receive: ReceivedObjectsOrRecentlySchema.optional().describe('Unwrap CoinWrapper objects and other objects received by this object and send them to the owner of its Permission object.'),
+    um: z.union([z.string(), z.null()]).optional().describe('Contact object.'),
+}).strict().describe("On-chain Machine operations. USAGE: (1) CREATE NEW: Set 'object' field with {name, permission, ...} to create a Machine. NOTE: 'name' goes INSIDE 'object', NOT at the data root level. 'permission' can be a new Permission object or reference an existing one - check 'object' field description for details. (2) OPERATE EXISTING: Set 'object' field with object ID or name. The 'object' field is CRITICAL and REQUIRED in both cases.");
+export const CallMachine_InputSchema = z.object({
+    data: CallMachine_DataSchema,
+    env: CallEnvSchema.optional(),
+    submission: SubmissionCallSchema.optional(),
+}).strict();
+// MachineNode2File_InputSchema - 用于 machineNode2file 函数
+export const MachineNode2File_InputSchema = z.object({
+    machine: NameOrAddressSchema.describe("Machine object ID or name to export"),
+    file_path: z.string().describe("Output file path (absolute or relative)"),
+    format: z.enum(["json", "markdown"]).optional().describe("Output format: 'json' (default) or 'markdown'"),
+    env: CallEnvSchema.optional(),
+}).strict().describe("Query a Machine object from the blockchain and export its node definition to a JSON or Markdown file. The exported file can be edited and used to create new Machine objects.");
+// MachineNode2File_OutputSchema - machineNode2file 输出 schema
+export const MachineNode2File_OutputSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("success"),
+        data: z.object({
+            file_path: z.string().describe("Absolute path of the exported file"),
+            format: z.enum(["json", "markdown"]).describe("Export format"),
+            machine_object: NameOrAddressSchema.describe("Machine object ID"),
+            node_count: z.number().describe("Number of nodes exported"),
+        }).strict().describe("Success result data"),
+    }).strict(),
+    z.object({
+        status: z.literal("error"),
+        error: z.string().describe("Error message"),
+    }).strict(),
+]).describe("MachineNode2File operation output");
+// MachineNode2File_OutputWrappedSchema - 包装后的输出 schema
+export const MachineNode2File_OutputWrappedSchema = z.object({
+    result: MachineNode2File_OutputSchema,
+}).strict().describe("MachineNode2File operation output wrapped schema");

package/dist/schema/call/order.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const ArbConfirmSchema: any;
+export declare const ArbObjectionSchema: any;
+export declare const ArbClaimCompensationSchema: any;
+export declare const CallOrder_DataSchema: any;
+export declare const CallOrder_InputSchema: any;
+export type ArbConfirm = z.infer<typeof ArbConfirmSchema>;
+export type ArbObjection = z.infer<typeof ArbObjectionSchema>;
+export type ArbClaimCompensation = z.infer<typeof ArbClaimCompensationSchema>;
+export type CallOrder_Data = z.infer<typeof CallOrder_DataSchema>;
+export type CallOrder_Input = z.infer<typeof CallOrder_InputSchema>;

package/dist/schema/call/order.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { CallEnvSchema, SubmissionCallSchema } from "./base.js";
+import { OperateSchema } from "./progress.js";
+import { AccountOrMark_AddressSchema, DescriptionSchema, LongNameSchema, ManyAccountOrMark_AddressSchema, NameOrAddressSchema } from "../common/index.js";
+import { QueryReceivedResultSchema } from "../common/index.js";
+// 定义arb_confirm schema
+export const ArbConfirmSchema = z.object({
+    arb: NameOrAddressSchema.describe("Arb object ID or name."),
+    confirm: z.boolean().describe("Whether to confirm that the submitted arbitration materials are valid for arbitration."),
+    description: DescriptionSchema.optional().describe("Message description for compensation application."),
+    proposition: z.array(LongNameSchema).optional().describe("Compensation claims.")
+}).strict();
+// 定义arb_objection schema
+export const ArbObjectionSchema = z.object({
+    arb: NameOrAddressSchema.describe("Arb object ID or name."),
+    objection: DescriptionSchema.describe("Oppose and appeal the arbitration result, request re-arbitration"),
+}).strict();
+// 定义arb_claim_compensation schema
+export const ArbClaimCompensationSchema = z.object({
+    arb: NameOrAddressSchema.describe("Arb object ID or name."),
+}).strict();
+// 定义CallOrder_Data schema
+export const CallOrder_DataSchema = z.object({
+    object: NameOrAddressSchema.describe("Order object ID or name."),
+    agents: ManyAccountOrMark_AddressSchema.optional().describe("Order agents. Agents can operate the order, such as canceling the order, modifying the order status, etc.; but cannot receive the funds received by the order."),
+    required_info: z.union([NameOrAddressSchema, z.null()]).optional().describe("Contact object ID (recipient) or WTS Proof object (delivery proof) that information has been delivered via Wowok Messenger."),
+    progress: OperateSchema.optional().describe("Advance order process"),
+    arb_confirm: ArbConfirmSchema.optional().describe("Submit compensation request and apply for arbitration"),
+    arb_objection: ArbObjectionSchema.optional().describe("Oppose and appeal the arbitration result, request re-arbitration."),
+    arb_claim_compensation: ArbClaimCompensationSchema.optional().describe("Specify the adjudicated Arb object to obtain order compensation."),
+    receive: QueryReceivedResultSchema.optional().describe("Unwrap CoinWrapper objects or other objects received by the order and transfer them to the order owner"),
+    transfer_to: AccountOrMark_AddressSchema.optional().describe("Set new owner of the order. Requires order owner permission to set."),
+}).strict().describe("On-chain, operate on an Order object.");
+// 定义输入schema
+export const CallOrder_InputSchema = z.object({
+    data: CallOrder_DataSchema,
+    env: CallEnvSchema.optional(),
+    submission: SubmissionCallSchema.optional(),
+}).strict();

package/dist/schema/call/payment.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const RevenueSchema: any;
+export declare const CallPayment_DataSchema: any;
+export declare const CallPayment_InputSchema: any;
+export type Revenue = z.infer<typeof RevenueSchema>;
+export type CallPayment_Data = z.infer<typeof CallPayment_DataSchema>;
+export type CallPayment_Input = z.infer<typeof CallPayment_InputSchema>;

package/dist/schema/call/payment.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { PaymentInfoSchema } from "../query/index.js";
+import { CoinParamSchema, CallEnvSchema, TypeNamedObjectSchema } from "./base.js";
+import { AccountOrMark_AddressSchema } from "../common/index.js";
+// 定义Revenue schema
+export const RevenueSchema = z.object({
+    recipient: AccountOrMark_AddressSchema,
+    amount: CoinParamSchema
+}).strict().describe("Payment recipient and amount");
+// 定义CallPayment_Data schema
+export const CallPayment_DataSchema = z.object({
+    object: TypeNamedObjectSchema,
+    revenue: z.array(RevenueSchema).describe("Array of payment recipients and amounts"),
+    info: PaymentInfoSchema
+}).strict().describe("On-chain Payment creation. USAGE: Set 'object' field with {name, type, ...} to create a named Payment. NOTE: 'name' goes INSIDE 'object', NOT at the data root level. Payment is an immutable object - it can only be created, not modified. The 'object' field is CRITICAL and REQUIRED.");
+// 定义输入schema
+export const CallPayment_InputSchema = z.object({
+    data: CallPayment_DataSchema,
+    env: CallEnvSchema.optional(),
+}).strict();

package/dist/schema/call/permission.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const RemarkSetSchema: any;
+export declare const RemarkRemoveSchema: any;
+export declare const RemarkClearSchema: any;
+export declare const RemarkSchema: any;
+export declare const TablePermByIndexSchema: any;
+export declare const TablePermByEntitySchema: any;
+export declare const TableSchema: any;
+export declare const EntitySwapReplaceCopySchema: any;
+export declare const EntityDelSchema: any;
+export declare const EntitySchema: any;
+export declare const AdminSchema: any;
+export declare const CallPermission_DataSchema: any;
+export declare const CallPermission_InputSchema: any;
+export type RemarkSet = z.infer<typeof RemarkSetSchema>;
+export type RemarkRemove = z.infer<typeof RemarkRemoveSchema>;
+export type RemarkClear = z.infer<typeof RemarkClearSchema>;
+export type Remark = z.infer<typeof RemarkSchema>;
+export type TablePermByIndex = z.infer<typeof TablePermByIndexSchema>;
+export type TablePermByEntity = z.infer<typeof TablePermByEntitySchema>;
+export type Table = z.infer<typeof TableSchema>;
+export type EntitySwapReplaceCopy = z.infer<typeof EntitySwapReplaceCopySchema>;
+export type EntityDel = z.infer<typeof EntityDelSchema>;
+export type Entity = z.infer<typeof EntitySchema>;
+export type Admin = z.infer<typeof AdminSchema>;
+export type CallPermission_Data = z.infer<typeof CallPermission_DataSchema>;
+export type CallPermission_Input = z.infer<typeof CallPermission_InputSchema>;