callman-mcp 0.7.1 → 0.8.0

package/dist/tools/mockShared.d.ts

@@ -0,0 +1,983 @@
+import { z } from "zod";
+import type { LocalMockRecord, LocalMockRouteRecord, MockApiDetail, MockApiRoute, MockApiSummary } from "../client/types.js";
+import type { ToolContext } from "../context.js";
+import { type Named, type Resolved } from "../domain/resolve.js";
+export declare const MOCK_METHODS: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "ANY"];
+export declare const mockResponseSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"static" | "template">;
+    statusCode: z.ZodNumber;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+}, "strict", z.ZodTypeAny, {
+    type: "static" | "template";
+    statusCode: number;
+    headers?: Record<string, string> | undefined;
+    body?: unknown;
+}, {
+    type: "static" | "template";
+    statusCode: number;
+    headers?: Record<string, string> | undefined;
+    body?: unknown;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"static" | "template">;
+    statusCode: z.ZodNumber;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+}, "strict", z.ZodTypeAny, {
+    type: "static" | "template";
+    statusCode: number;
+    headers?: Record<string, string> | undefined;
+    body?: unknown;
+}, {
+    type: "static" | "template";
+    statusCode: number;
+    headers?: Record<string, string> | undefined;
+    body?: unknown;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"builder">;
+    preset: z.ZodEnum<["list", "detail", "create", "update", "delete", "echo", "custom"]>;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strict", z.ZodTypeAny, {
+    type: "builder";
+    config: Record<string, unknown>;
+    preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+}, {
+    type: "builder";
+    config: Record<string, unknown>;
+    preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+}>]>;
+export declare const mockRouteInputSchema: z.ZodObject<{
+    method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "ANY"]>;
+    path: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    response: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"static" | "template">;
+        statusCode: z.ZodNumber;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    }, {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"static" | "template">;
+        statusCode: z.ZodNumber;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    }, {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"builder">;
+        preset: z.ZodEnum<["list", "detail", "create", "update", "delete", "echo", "custom"]>;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        type: "builder";
+        config: Record<string, unknown>;
+        preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+    }, {
+        type: "builder";
+        config: Record<string, unknown>;
+        preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+    }>]>>;
+    statusCode: z.ZodOptional<z.ZodNumber>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    variants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        variantId: z.ZodOptional<z.ZodString>;
+        priority: z.ZodNumber;
+        condition: z.ZodObject<{
+            type: z.ZodEnum<["all", "any"]>;
+            rules: z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<["exists", "not-exists", "equals", "not-equals", "contains", "starts-with", "matches"]>;
+                value: z.ZodOptional<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }, {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        }, {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        }>;
+        response: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"static" | "template">;
+            statusCode: z.ZodNumber;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            body: z.ZodOptional<z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        }, {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"static" | "template">;
+            statusCode: z.ZodNumber;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            body: z.ZodOptional<z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        }, {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"builder">;
+            preset: z.ZodEnum<["list", "detail", "create", "update", "delete", "echo", "custom"]>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        }, {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        }>]>;
+    }, "strict", z.ZodTypeAny, {
+        priority: number;
+        response: {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        } | {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        };
+        condition: {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        };
+        variantId?: string | undefined;
+    }, {
+        priority: number;
+        response: {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        } | {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        };
+        condition: {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        };
+        variantId?: string | undefined;
+    }>, "many">>;
+    delay: z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "none";
+    }, {
+        mode: "none";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"fixed">;
+        ms: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        mode: "fixed";
+        ms: number;
+    }, {
+        mode: "fixed";
+        ms: number;
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"random">;
+        minMs: z.ZodNumber;
+        maxMs: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    }, {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    }>]>>;
+    requestValidation: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        mode: z.ZodEnum<["any", "schema"]>;
+        schema: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        mode: "any" | "schema";
+        schema?: unknown;
+    }, {
+        mode: "any" | "schema";
+        schema?: unknown;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "ANY";
+    path: string;
+    headers?: Record<string, string> | undefined;
+    name?: string | undefined;
+    body?: unknown;
+    statusCode?: number | undefined;
+    response?: {
+        type: "builder";
+        config: Record<string, unknown>;
+        preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+    } | {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    } | undefined;
+    delay?: {
+        mode: "none";
+    } | {
+        mode: "fixed";
+        ms: number;
+    } | {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    } | undefined;
+    requestValidation?: {
+        mode: "any" | "schema";
+        schema?: unknown;
+    } | null | undefined;
+    variants?: {
+        priority: number;
+        response: {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        } | {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        };
+        condition: {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        };
+        variantId?: string | undefined;
+    }[] | undefined;
+}, {
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "ANY";
+    path: string;
+    headers?: Record<string, string> | undefined;
+    name?: string | undefined;
+    body?: unknown;
+    statusCode?: number | undefined;
+    response?: {
+        type: "builder";
+        config: Record<string, unknown>;
+        preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+    } | {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    } | undefined;
+    delay?: {
+        mode: "none";
+    } | {
+        mode: "fixed";
+        ms: number;
+    } | {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    } | undefined;
+    requestValidation?: {
+        mode: "any" | "schema";
+        schema?: unknown;
+    } | null | undefined;
+    variants?: {
+        priority: number;
+        response: {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        } | {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        };
+        condition: {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        };
+        variantId?: string | undefined;
+    }[] | undefined;
+}>;
+export declare const mockRoutePatchSchema: z.ZodObject<{
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "ANY"]>>;
+    path: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    response: z.ZodOptional<z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"static" | "template">;
+        statusCode: z.ZodNumber;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    }, {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"static" | "template">;
+        statusCode: z.ZodNumber;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    }, {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"builder">;
+        preset: z.ZodEnum<["list", "detail", "create", "update", "delete", "echo", "custom"]>;
+        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        type: "builder";
+        config: Record<string, unknown>;
+        preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+    }, {
+        type: "builder";
+        config: Record<string, unknown>;
+        preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+    }>]>>>;
+    statusCode: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+    headers: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    body: z.ZodOptional<z.ZodOptional<z.ZodUnknown>>;
+    variants: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        variantId: z.ZodOptional<z.ZodString>;
+        priority: z.ZodNumber;
+        condition: z.ZodObject<{
+            type: z.ZodEnum<["all", "any"]>;
+            rules: z.ZodArray<z.ZodObject<{
+                field: z.ZodString;
+                operator: z.ZodEnum<["exists", "not-exists", "equals", "not-equals", "contains", "starts-with", "matches"]>;
+                value: z.ZodOptional<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }, {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }>, "many">;
+        }, "strict", z.ZodTypeAny, {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        }, {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        }>;
+        response: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"static" | "template">;
+            statusCode: z.ZodNumber;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            body: z.ZodOptional<z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        }, {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"static" | "template">;
+            statusCode: z.ZodNumber;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            body: z.ZodOptional<z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        }, {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"builder">;
+            preset: z.ZodEnum<["list", "detail", "create", "update", "delete", "echo", "custom"]>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        }, {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        }>]>;
+    }, "strict", z.ZodTypeAny, {
+        priority: number;
+        response: {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        } | {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        };
+        condition: {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        };
+        variantId?: string | undefined;
+    }, {
+        priority: number;
+        response: {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        } | {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        };
+        condition: {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        };
+        variantId?: string | undefined;
+    }>, "many">>>;
+    delay: z.ZodOptional<z.ZodOptional<z.ZodDiscriminatedUnion<"mode", [z.ZodObject<{
+        mode: z.ZodLiteral<"none">;
+    }, "strict", z.ZodTypeAny, {
+        mode: "none";
+    }, {
+        mode: "none";
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"fixed">;
+        ms: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        mode: "fixed";
+        ms: number;
+    }, {
+        mode: "fixed";
+        ms: number;
+    }>, z.ZodObject<{
+        mode: z.ZodLiteral<"random">;
+        minMs: z.ZodNumber;
+        maxMs: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    }, {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    }>]>>>;
+    requestValidation: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        mode: z.ZodEnum<["any", "schema"]>;
+        schema: z.ZodOptional<z.ZodUnknown>;
+    }, "strict", z.ZodTypeAny, {
+        mode: "any" | "schema";
+        schema?: unknown;
+    }, {
+        mode: "any" | "schema";
+        schema?: unknown;
+    }>>>>;
+}, "strict", z.ZodTypeAny, {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "ANY" | undefined;
+    headers?: Record<string, string> | undefined;
+    name?: string | undefined;
+    body?: unknown;
+    statusCode?: number | undefined;
+    path?: string | undefined;
+    response?: {
+        type: "builder";
+        config: Record<string, unknown>;
+        preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+    } | {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    } | undefined;
+    delay?: {
+        mode: "none";
+    } | {
+        mode: "fixed";
+        ms: number;
+    } | {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    } | undefined;
+    requestValidation?: {
+        mode: "any" | "schema";
+        schema?: unknown;
+    } | null | undefined;
+    variants?: {
+        priority: number;
+        response: {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        } | {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        };
+        condition: {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        };
+        variantId?: string | undefined;
+    }[] | undefined;
+}, {
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "ANY" | undefined;
+    headers?: Record<string, string> | undefined;
+    name?: string | undefined;
+    body?: unknown;
+    statusCode?: number | undefined;
+    path?: string | undefined;
+    response?: {
+        type: "builder";
+        config: Record<string, unknown>;
+        preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+    } | {
+        type: "static" | "template";
+        statusCode: number;
+        headers?: Record<string, string> | undefined;
+        body?: unknown;
+    } | undefined;
+    delay?: {
+        mode: "none";
+    } | {
+        mode: "fixed";
+        ms: number;
+    } | {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    } | undefined;
+    requestValidation?: {
+        mode: "any" | "schema";
+        schema?: unknown;
+    } | null | undefined;
+    variants?: {
+        priority: number;
+        response: {
+            type: "builder";
+            config: Record<string, unknown>;
+            preset: "list" | "create" | "update" | "delete" | "custom" | "detail" | "echo";
+        } | {
+            type: "static" | "template";
+            statusCode: number;
+            headers?: Record<string, string> | undefined;
+            body?: unknown;
+        };
+        condition: {
+            type: "any" | "all";
+            rules: {
+                operator: "equals" | "exists" | "contains" | "not-exists" | "not-equals" | "starts-with" | "matches";
+                field: string;
+                value?: string | undefined;
+            }[];
+        };
+        variantId?: string | undefined;
+    }[] | undefined;
+}>;
+export type MockRouteInput = z.infer<typeof mockRouteInputSchema>;
+export type MockRoutePatch = z.infer<typeof mockRoutePatchSchema>;
+export declare const assertRoutePath: (path: string, where: string) => void;
+export declare const toServerRoute: (input: MockRouteInput, where: string) => Record<string, unknown>;
+export declare const toServerRoutePatch: (patch: MockRoutePatch, current: MockApiRoute, where: string) => Record<string, unknown>;
+export declare const duplicateRoutes: (routes: Array<{
+    method: string;
+    path: string;
+}>) => string[];
+export declare const mockListView: (mock: MockApiSummary) => {
+    auth: "token" | "public";
+    publicUrl: string;
+    requestCount: number;
+    expiresAt: string;
+    expired: boolean;
+    createdAt: string;
+    description?: string | undefined;
+    mockId: string;
+    id: string;
+    name: string;
+};
+export declare const mockSummaryView: (mock: MockApiSummary) => {
+    routeCount: number;
+    stateSizeBytes: number;
+    auth: "token" | "public";
+    publicUrl: string;
+    requestCount: number;
+    expiresAt: string;
+    expired: boolean;
+    createdAt: string;
+    description?: string | undefined;
+    mockId: string;
+    id: string;
+    name: string;
+};
+export declare const alternativeUrl: (apiUrl: string, mock: Pick<MockApiSummary, "mockId" | "publicUrl">) => Record<string, string>;
+export declare const routeView: (route: MockApiRoute) => {
+    requestValidation?: {
+        mode: "any" | "schema";
+        schema?: unknown;
+    } | undefined;
+    delay: Record<string, unknown>;
+    variants?: Record<string, unknown>[] | undefined;
+    response: Record<string, unknown>;
+    name?: string | undefined;
+    routeId: string;
+    method: import("../client/types.js").MockHttpMethod;
+    path: string;
+};
+export declare const routesView: (routes: MockApiRoute[]) => {
+    routes: {
+        requestValidation?: {
+            mode: "any" | "schema";
+            schema?: unknown;
+        } | undefined;
+        delay: Record<string, unknown>;
+        variants?: Record<string, unknown>[] | undefined;
+        response: Record<string, unknown>;
+        name?: string | undefined;
+        routeId: string;
+        method: import("../client/types.js").MockHttpMethod;
+        path: string;
+    }[];
+    routesTruncated?: undefined;
+    routesNote?: undefined;
+} | {
+    routes: {
+        variants?: number | undefined;
+        statusCode?: number | undefined;
+        responseType: unknown;
+        name?: string | undefined;
+        routeId: string;
+        method: import("../client/types.js").MockHttpMethod;
+        path: string;
+    }[];
+    routesTruncated: boolean;
+    routesNote: string;
+};
+export declare const mockDetailView: (mock: MockApiDetail, apiUrl: string, auth: Record<string, unknown>) => {
+    routes: {
+        requestValidation?: {
+            mode: "any" | "schema";
+            schema?: unknown;
+        } | undefined;
+        delay: Record<string, unknown>;
+        variants?: Record<string, unknown>[] | undefined;
+        response: Record<string, unknown>;
+        name?: string | undefined;
+        routeId: string;
+        method: import("../client/types.js").MockHttpMethod;
+        path: string;
+    }[];
+    routesTruncated?: undefined;
+    routesNote?: undefined;
+    auth: Record<string, unknown>;
+    limits: {
+        totalRequests: number;
+        rateLimitPerSecond: number;
+    };
+    routeCount: number;
+    stateSizeBytes: number;
+    publicUrl: string;
+    requestCount: number;
+    expiresAt: string;
+    expired: boolean;
+    createdAt: string;
+    description?: string | undefined;
+    mockId: string;
+    id: string;
+    name: string;
+} | {
+    routes: {
+        variants?: number | undefined;
+        statusCode?: number | undefined;
+        responseType: unknown;
+        name?: string | undefined;
+        routeId: string;
+        method: import("../client/types.js").MockHttpMethod;
+        path: string;
+    }[];
+    routesTruncated: boolean;
+    routesNote: string;
+    auth: Record<string, unknown>;
+    limits: {
+        totalRequests: number;
+        rateLimitPerSecond: number;
+    };
+    routeCount: number;
+    stateSizeBytes: number;
+    publicUrl: string;
+    requestCount: number;
+    expiresAt: string;
+    expired: boolean;
+    createdAt: string;
+    description?: string | undefined;
+    mockId: string;
+    id: string;
+    name: string;
+};
+export declare const sampleRoutePath: (path: string) => string;
+export interface CurlRoute {
+    method: string;
+    path: string;
+    response?: Record<string, unknown>;
+    requestValidation?: {
+        mode?: string;
+        schema?: unknown;
+    } | null;
+}
+export declare const curlLine: (baseUrl: string, route: CurlRoute, token: string | null | undefined) => string;
+export declare const mockRefArg: (what: string) => z.ZodString;
+export declare const targetArg: z.ZodOptional<z.ZodEnum<["server", "desktop"]>>;
+export declare const requireTarget: (target: "server" | "desktop", args: Record<string, unknown>, only: "server" | "desktop", hint: string) => void;
+interface MockRef extends Named {
+    summary: MockApiSummary;
+}
+export declare const loadMocks: (ctx: ToolContext, ws: string) => Promise<MockApiSummary[]>;
+export declare const resolveMock: (ctx: ToolContext, ws: string, ref: string, options?: {
+    exact?: boolean;
+}) => Promise<Resolved<MockRef>>;
+export declare const findMock: (ctx: ToolContext, workspace: string | null | undefined, ref: string, options?: {
+    exact?: boolean;
+}) => Promise<import("./lookups.js").Found<Resolved<MockRef>>>;
+export declare const resolveRoute: (mock: MockApiDetail, ref: string) => MockApiRoute;
+export declare const LOCAL_BODY_MAX_BYTES: number;
+export declare const LOCAL_DELAY_MAX_MS = 30000;
+export declare const toLocalRoute: (input: MockRouteInput, where: string) => LocalMockRouteRecord;
+export declare const localBaseUrl: (mock: Pick<LocalMockRecord, "port">) => string;
+export declare const localRouteView: (route: LocalMockRouteRecord) => {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: string;
+    delay: {
+        mode: "none";
+    } | {
+        mode: "fixed";
+        ms: number;
+    } | {
+        mode: "random";
+        minMs: number;
+        maxMs: number;
+    };
+    name?: string | undefined;
+    method: import("../client/types.js").MockHttpMethod;
+    path: string;
+    routeId?: string | undefined;
+};
+export declare const localMockView: (mock: LocalMockRecord, options?: {
+    routes: boolean;
+}) => {
+    routes: {
+        statusCode: number;
+        headers: Record<string, string>;
+        body: string;
+        delay: {
+            mode: "none";
+        } | {
+            mode: "fixed";
+            ms: number;
+        } | {
+            mode: "random";
+            minMs: number;
+            maxMs: number;
+        };
+        name?: string | undefined;
+        method: import("../client/types.js").MockHttpMethod;
+        path: string;
+        routeId?: string | undefined;
+    }[];
+    requestCount: number;
+    routeCount: number;
+    lastError?: string | undefined;
+    source?: string | undefined;
+    id: string;
+    name: string;
+    port: number;
+    running: boolean;
+    baseUrl: string;
+    autoStart: boolean;
+} | {
+    routes: {
+        statusCode: number;
+        delay: {
+            mode: "none";
+        } | {
+            mode: "fixed";
+            ms: number;
+        } | {
+            mode: "random";
+            minMs: number;
+            maxMs: number;
+        };
+        name?: string | undefined;
+        method: import("../client/types.js").MockHttpMethod;
+        path: string;
+        routeId?: string | undefined;
+    }[];
+    routesTruncated: boolean;
+    requestCount: number;
+    routeCount: number;
+    lastError?: string | undefined;
+    source?: string | undefined;
+    id: string;
+    name: string;
+    port: number;
+    running: boolean;
+    baseUrl: string;
+    autoStart: boolean;
+} | {
+    requestCount: number;
+    routeCount: number;
+    lastError?: string | undefined;
+    source?: string | undefined;
+    id: string;
+    name: string;
+    port: number;
+    running: boolean;
+    baseUrl: string;
+    autoStart: boolean;
+};
+export declare const localCalls: (mock: LocalMockRecord) => {
+    route: string;
+    curl: string;
+}[];
+export declare const resolveLocalMock: (mocks: LocalMockRecord[], ref: string, options?: {
+    exact?: boolean;
+}) => Resolved<Named & {
+    record: LocalMockRecord;
+}>;
+interface LogEntry {
+    _id?: unknown;
+    createdAt?: unknown;
+    request?: {
+        method?: string;
+        path?: string;
+        query?: Record<string, unknown>;
+        body?: unknown;
+    };
+    response?: {
+        statusCode?: number;
+        durationMs?: number;
+        body?: unknown;
+    };
+    matchInfo?: {
+        matched?: boolean;
+        matchedRouteId?: string;
+        matchedVariantId?: string;
+        failureReason?: string;
+    };
+}
+export declare const logView: (entry: LogEntry) => {
+    failureReason?: string | undefined;
+    variantId?: string | undefined;
+    routeId?: string | undefined;
+    matched: boolean;
+    responseBody?: string | null | undefined;
+    statusCode: number | undefined;
+    durationMs: number | undefined;
+    requestBody?: string | null | undefined;
+    query?: Record<string, unknown> | undefined;
+    id: string;
+    at: unknown;
+    method: string | undefined;
+    path: string | undefined;
+};
+export {};
+//# sourceMappingURL=mockShared.d.ts.map