argsbarg 6.0.2 → 6.1.0

package/src/cli-tool/schemagen/schemagen.test.ts

@@ -39,10 +39,10 @@ function makeTempProject(): string {
   return root;
 }
 
-function writeSchema(root: string, relDir: string, body: string): void {
+function writeTypes(root: string, relDir: string, body: string): void {
   const dir = join(root, "src", relDir);
   mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, "schema.ts"), body);
+  writeFileSync(join(dir, "types.ts"), body);
 }
 
 describe("schemagen", () => {
@@ -62,14 +62,38 @@ describe("schemagen", () => {
     expect(counts).toEqual({ configRoots: 1, inputRoots: 0, outputRoots: 1 });
   });
 
+  test("discovers roots from types.ts with interface and role export", () => {
+    const root = makeTempProject();
+    const dir = join(root, "src/commands/demo");
+    writeTypes(
+      root,
+      "commands/demo",
+      `export interface DemoOutput { ok: boolean; }
+
+/** Schemagen root for leaf outputSchema. */
+export type outputType = DemoOutput;
+`,
+    );
+
+    const roots = discoverSchemaRoots(root);
+    expect(roots).toEqual([
+      {
+        kind: "output",
+        typeName: "DemoOutput",
+        path: "src/commands/demo/types.ts",
+        sourcePath: "src/commands/demo/types.ts",
+      },
+    ]);
+    runSchemagen({ projectRoot: root });
+    expect(existsSync(join(dir, "__generated__/outputSchema.json"))).toBe(true);
+  });
+
   test("removes stale JSON files when a schema kind is dropped", () => {
     const root = makeTempProject();
-    writeSchema(
+    writeTypes(
       root,
       "commands/demo",
-      `/** Tool input. */
-export interface DemoInput { id: string; }
-/** Tool output. */
+      `export interface DemoInput { id: string; }
 export interface DemoOutput { ok: boolean; }
 export type inputType = DemoInput;
 export type outputType = DemoOutput;
@@ -81,11 +105,10 @@ export type outputType = DemoOutput;
     expect(existsSync(join(generatedDir, "inputSchema.json"))).toBe(true);
     expect(existsSync(join(generatedDir, "outputSchema.json"))).toBe(true);
 
-    writeSchema(
+    writeTypes(
       root,
       "commands/demo",
-      `/** Tool output. */
-export interface DemoOutput { ok: boolean; }
+      `export interface DemoOutput { ok: boolean; }
 export type outputType = DemoOutput;
 `,
     );
@@ -96,7 +119,7 @@ export type outputType = DemoOutput;
     expect(existsSync(join(generatedDir, "index.ts"))).toBe(true);
   });
 
-  test("removes orphan __generated__ when schema.ts is gone", () => {
+  test("removes orphan __generated__ when types.ts manifest is gone", () => {
     const root = makeTempProject();
     const generatedDir = join(root, "src/orphan/__generated__");
     mkdirSync(generatedDir, { recursive: true });
@@ -107,14 +130,9 @@ export type outputType = DemoOutput;
     expect(existsSync(generatedDir)).toBe(false);
   });
 
-  test("removes __generated__ when schema.ts has no discoverable roots", () => {
+  test("removes __generated__ when types.ts has no discoverable roots", () => {
     const root = makeTempProject();
-    writeSchema(
-      root,
-      "commands/empty",
-      `export type outputType = never;
-`,
-    );
+    writeTypes(root, "commands/empty", `export type outputType = never;\n`);
     const generatedDir = join(root, "src/commands/empty/__generated__");
     mkdirSync(generatedDir, { recursive: true });
     writeFileSync(join(generatedDir, "outputSchema.json"), "{}\n");

package/src/context.ts

@@ -10,6 +10,7 @@ parsed values.
 import type { AnyAppConfigSnapshot } from "./config/context.ts";
 import { EmptyAppConfigSnapshot } from "./config/context.ts";
 import { parseCommaList, parseDate, parseDateTime, parseDurationMs } from "./formats.ts";
+import { readLeafInputsAsync as loadLeafInputsAsync } from "./leaf-inputs.ts";
 import { collectOptionDefs } from "./parse.ts";
 import { normalizeRespondOptions, writeRespondBodyToStdout } from "./respond.ts";
 import type { CliInvocation, CliLeaf, CliNode, CliOption, CliProgram, CliRespondOptions } from "./types.ts";
@@ -17,7 +18,7 @@ import { CliOptionKind, CliValueFormat, isCliLeaf, isCliRouter } from "./types.t
 import { strictParseDouble } from "./utils.ts";
 
 /** Coerced leaf inputs keyed by option and positional names. */
-export type CliLeafInputs = Record<string, boolean | number | string | string[] | undefined>;
+export type CliLeafInputs = Record<string, boolean | number | string | string[] | unknown | undefined>;
 
 /**
  * Values passed to a leaf command handler after parsing: app name, routed path, args, and merged options.
@@ -163,7 +164,15 @@ export class CliContext {
     return out;
   }
 
-  private _readOptionValue(opt: CliOption): boolean | number | string | string[] | undefined {
+  /**
+   * Reads coerced leaf inputs, resolving Json options from flags, piped stdin (when `pipable`),
+   * or MCP/API toolArgs, and validates against `leaf.inputSchema` when set.
+   */
+  async readLeafInputsAsync(): Promise<CliLeafInputs> {
+    return loadLeafInputsAsync(this);
+  }
+
+  private _readOptionValue(opt: CliOption): boolean | number | string | string[] | unknown | undefined {
     if (opt.kind === CliOptionKind.Presence) {
       return this.hasFlag(opt.name);
     }
@@ -171,6 +180,15 @@ export class CliContext {
       const n = this.numberOpt(opt.name);
       return n === null ? undefined : n;
     }
+    if (opt.kind === CliOptionKind.Json) {
+      const raw = this.stringOpt(opt.name);
+      if (raw === undefined) return undefined;
+      try {
+        return JSON.parse(raw) as unknown;
+      } catch {
+        return undefined;
+      }
+    }
     if (opt.format === CliValueFormat.Duration) {
       return this.durationOpt(opt.name);
     }

package/src/help.ts

@@ -178,6 +178,8 @@ function optKindLabel(k: CliOptionKind, o?: CliOption): string {
       }
       return ` <${choices.slice(0, 3).join("|")}|…>`;
     }
+    case CliOptionKind.Json:
+      return " <json>";
   }
 }
 

package/src/index.ts

@@ -28,6 +28,7 @@ export {
   shouldRunHeadlessWithYes,
   wantsExplicitJson,
 } from "./headless.ts";
+export { LeafInputError, readLeafInputsAsync } from "./leaf-inputs.ts";
 export type { McpBundlePaths, PackMcpBundleOpts } from "./mcp/bundle.ts";
 export { defaultMcpBundlePaths, generateMcpManifest, packMcpBundle } from "./mcp/bundle.ts";
 export type {

package/src/leaf-inputs.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, test } from "bun:test";
+import { Cli, CliContext, CliOptionKind } from "./index.ts";
+import { LeafInputError, readLeafInputsAsync } from "./leaf-inputs.ts";
+import type { CliProgram } from "./types.ts";
+
+const invoiceSchema = {
+  type: "object",
+  properties: {
+    format: { type: "string", enum: ["pdf", "html"] },
+    invoice: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+      },
+      required: ["id"],
+      additionalProperties: false,
+    },
+  },
+  required: ["format", "invoice"],
+  additionalProperties: false,
+} as const;
+
+function renderProgram(): CliProgram {
+  return {
+    key: "json-pipe-test",
+    version: "1.0.0",
+    description: "Json pipable option tests",
+    commands: [
+      {
+        key: "render",
+        description: "Render with pipable invoice JSON",
+        inputSchema: invoiceSchema,
+        options: [
+          {
+            name: "format",
+            description: "Output format",
+            kind: CliOptionKind.Enum,
+            choices: ["pdf", "html"],
+            required: true,
+          },
+          {
+            name: "invoice",
+            description: "Invoice JSON (flag or stdin)",
+            kind: CliOptionKind.Json,
+            pipable: true,
+            required: true,
+          },
+        ],
+        handler: async (ctx) => {
+          const inputs = await ctx.readLeafInputsAsync();
+          return inputs;
+        },
+      },
+    ],
+  } satisfies CliProgram;
+}
+
+describe("readLeafInputsAsync", () => {
+  test("reads Json option from MCP toolArgs", async () => {
+    const cli = new Cli(renderProgram());
+    const result = await cli.invoke(["render", "--format", "pdf"], {
+      invocation: "mcp",
+      toolArgs: { format: "pdf", invoice: { id: "INV-1" } },
+    });
+    expect(result.kind).toBe("ok");
+    expect(result.exitCode).toBe(0);
+    expect(result.response?.body).toEqual({
+      format: "pdf",
+      invoice: { id: "INV-1" },
+    });
+  });
+
+  test("flag wins over toolArgs for Json option", async () => {
+    const cli = new Cli(renderProgram());
+    const result = await cli.invoke(["render", "--format", "pdf", "--invoice", '{"id":"from-flag"}'], {
+      invocation: "mcp",
+      toolArgs: { format: "pdf", invoice: { id: "from-tool-args" } },
+    });
+    expect(result.kind).toBe("ok");
+    expect(result.response?.body).toEqual({
+      format: "pdf",
+      invoice: { id: "from-flag" },
+    });
+  });
+
+  test("rejects invalid Json flag at parse time", async () => {
+    const cli = new Cli(renderProgram());
+    const result = await cli.invoke(["render", "--format", "pdf", "--invoice", "not-json"], {
+      invocation: "mcp",
+      toolArgs: {},
+    });
+    expect(result.kind).toBe("error");
+    expect(result.errorMsg).toContain("Invalid JSON");
+  });
+
+  test("validates merged inputs against inputSchema", async () => {
+    const cli = new Cli(renderProgram());
+    const result = await cli.invoke(["render", "--format", "pdf"], {
+      invocation: "mcp",
+      toolArgs: { format: "pdf", invoice: { id: 123 } },
+    });
+    expect(result.kind).toBe("error");
+    expect(result.stderr).toContain("invoice.id");
+  });
+
+  test("readLeafInputsAsync throws LeafInputError when required Json is missing", async () => {
+    const program = renderProgram();
+    const ctx = new CliContext("json-pipe-test", ["render"], [], { format: "pdf" }, program, "mcp", undefined, {});
+    await expect(readLeafInputsAsync(ctx)).rejects.toThrow(LeafInputError);
+  });
+
+  test("omits undefined optional properties before inputSchema validation", async () => {
+    const schemaWithOptional = {
+      type: "object",
+      properties: {
+        format: { type: "string", enum: ["pdf", "html"] },
+        template: { type: "string" },
+        invoice: {
+          type: "object",
+          properties: { id: { type: "string" } },
+          required: ["id"],
+          additionalProperties: false,
+        },
+      },
+      required: ["format", "invoice"],
+      additionalProperties: false,
+    };
+    const program = {
+      key: "json-pipe-test",
+      version: "1.0.0",
+      description: "optional template",
+      commands: [
+        {
+          key: "render",
+          description: "Render",
+          inputSchema: schemaWithOptional,
+          options: [
+            {
+              name: "format",
+              description: "Output format",
+              kind: CliOptionKind.Enum,
+              choices: ["pdf", "html"],
+              required: true,
+            },
+            {
+              name: "template",
+              description: "Template name",
+              kind: CliOptionKind.String,
+            },
+            {
+              name: "invoice",
+              description: "Invoice JSON",
+              kind: CliOptionKind.Json,
+              pipable: true,
+              required: true,
+            },
+          ],
+          handler: async (ctx) => ctx.readLeafInputsAsync(),
+        },
+      ],
+    } satisfies CliProgram;
+    const cli = new Cli(program);
+    const result = await cli.invoke(["render", "--format", "pdf"], {
+      invocation: "mcp",
+      toolArgs: { format: "pdf", invoice: { id: "INV-1" } },
+    });
+    expect(result.kind).toBe("ok");
+    expect(result.response?.body).toEqual({ format: "pdf", invoice: { id: "INV-1" } });
+  });
+});

package/src/leaf-inputs.ts

@@ -0,0 +1,178 @@
+/*
+Async leaf input reads: Json options (flag, piped stdin, or toolArgs), optional inputSchema validation.
+*/
+
+import { validateConfigDocument } from "./config/validate.ts";
+import type { CliContext, CliLeafInputs } from "./context.ts";
+import { collectOptionDefs } from "./parse.ts";
+import type { CliLeaf, CliNode, CliOption } from "./types.ts";
+import { CliOptionKind, CliValueFormat, isCliLeaf, isCliRouter } from "./types.ts";
+import { isInteractiveTty } from "./utils.ts";
+
+/** Thrown when {@link CliContext.readLeafInputsAsync} cannot resolve or validate inputs. */
+export class LeafInputError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "LeafInputError";
+  }
+}
+
+function leafNode(ctx: CliContext): CliLeaf | undefined {
+  let node: CliNode = ctx.program;
+  for (const seg of ctx.commandPath) {
+    if (!isCliRouter(node)) return undefined;
+    const child = node.commands.find((c) => c.key === seg);
+    if (!child) return undefined;
+    node = child;
+  }
+  return isCliLeaf(node) ? node : undefined;
+}
+
+function readSyncOptionValue(
+  ctx: CliContext,
+  opt: CliOption,
+): boolean | number | string | string[] | unknown | undefined {
+  if (opt.kind === CliOptionKind.Presence) {
+    return ctx.hasFlag(opt.name);
+  }
+  if (opt.kind === CliOptionKind.Number) {
+    const n = ctx.numberOpt(opt.name);
+    return n === null ? undefined : n;
+  }
+  if (opt.kind === CliOptionKind.Json) {
+    const raw = ctx.stringOpt(opt.name);
+    if (raw === undefined) return undefined;
+    return parseJsonText(raw, `--${opt.name}`);
+  }
+  if (opt.format !== undefined) {
+    if (opt.format === CliValueFormat.Duration) {
+      return ctx.durationOpt(opt.name);
+    }
+    if (opt.format === CliValueFormat.CommaList) {
+      return ctx.commaListOpt(opt.name);
+    }
+    if (opt.format === CliValueFormat.Date) {
+      return ctx.dateOpt(opt.name);
+    }
+    if (opt.format === CliValueFormat.DateTime) {
+      return ctx.dateTimeOpt(opt.name);
+    }
+  }
+  return ctx.stringOpt(opt.name);
+}
+
+function parseJsonText(raw: string, label: string): unknown {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    throw new LeafInputError(`${label}: JSON value is empty`);
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    throw new LeafInputError(`${label}: invalid JSON`);
+  }
+}
+
+async function readPipedJsonStdin(): Promise<unknown> {
+  const raw = await new Response(Bun.stdin).text();
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    throw new LeafInputError("stdin is empty; pass JSON via the option flag or pipe a JSON document to stdin");
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    throw new LeafInputError("stdin is not valid JSON");
+  }
+}
+
+function pipableJsonHelp(opt: CliOption): string {
+  return `Missing required option --${opt.name}: pass JSON via --${opt.name} '<json>' or pipe a JSON document to stdin`;
+}
+
+function omitUndefinedInputs(out: CliLeafInputs): Record<string, unknown> {
+  const stripped: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(out)) {
+    if (value !== undefined) {
+      stripped[key] = value;
+    }
+  }
+  return stripped;
+}
+
+function validateAgainstInputSchema(out: CliLeafInputs, inputSchema: Record<string, unknown>): void {
+  const result = validateConfigDocument(omitUndefinedInputs(out), inputSchema);
+  if (!result.valid) {
+    throw new LeafInputError(result.errors.join("; "));
+  }
+}
+
+/**
+ * Reads coerced leaf inputs, resolving Json options from flags, piped stdin, or toolArgs,
+ * and validates against `leaf.inputSchema` when set.
+ */
+export async function readLeafInputsAsync(ctx: CliContext): Promise<CliLeafInputs> {
+  const leaf = leafNode(ctx);
+  if (!leaf) return {};
+
+  const out: CliLeafInputs = {};
+  const options = collectOptionDefs(ctx.program, ctx.commandPath);
+  let pipedJson: unknown | undefined;
+  let pipedJsonRead = false;
+
+  for (const opt of options) {
+    if (opt.kind === CliOptionKind.Json) {
+      const flagValue = ctx.stringOpt(opt.name);
+      if (flagValue !== undefined) {
+        out[opt.name] = parseJsonText(flagValue, `--${opt.name}`);
+        continue;
+      }
+      if (ctx.toolArgs !== undefined && opt.name in ctx.toolArgs) {
+        out[opt.name] = ctx.toolArgs[opt.name];
+        continue;
+      }
+      if (opt.pipable && ctx.invocation === "cli") {
+        if (isInteractiveTty) {
+          out[opt.name] = undefined;
+          continue;
+        }
+        if (!pipedJsonRead) {
+          pipedJson = await readPipedJsonStdin();
+          pipedJsonRead = true;
+        }
+        out[opt.name] = pipedJson;
+        continue;
+      }
+      out[opt.name] = undefined;
+      continue;
+    }
+
+    out[opt.name] = readSyncOptionValue(ctx, opt);
+  }
+
+  for (const p of leaf.positionals ?? []) {
+    const val = ctx.positional(p.name);
+    if (val === undefined) {
+      out[p.name] = undefined;
+    } else if (Array.isArray(val)) {
+      out[p.name] = val;
+    } else {
+      out[p.name] = val;
+    }
+  }
+
+  for (const opt of options) {
+    if (opt.required && out[opt.name] === undefined) {
+      if (opt.kind === CliOptionKind.Json && opt.pipable && ctx.invocation === "cli" && isInteractiveTty) {
+        throw new LeafInputError(pipableJsonHelp(opt));
+      }
+      throw new LeafInputError(`Missing required option: --${opt.name}`);
+    }
+  }
+
+  if (leaf.inputSchema !== undefined) {
+    validateAgainstInputSchema(out, leaf.inputSchema);
+  }
+
+  return omitUndefinedInputs(out);
+}

package/src/mcp/tools.ts

@@ -116,6 +116,8 @@ function optionProperty(opt: CliOption): Record<string, unknown> {
       return { type: "number", ...base };
     case CliOptionKind.Enum:
       return { type: "string", enum: opt.choices, ...base };
+    case CliOptionKind.Json:
+      return { type: "object", ...base };
   }
 }
 
@@ -287,6 +289,9 @@ export function mcpToolCallToArgv(
   const argv = [...tool.path];
 
   for (const opt of collectOptionDefs(root, tool.path)) {
+    if (opt.kind === CliOptionKind.Json) {
+      continue;
+    }
     const val = args[opt.name];
     if (val === undefined) {
       continue;

package/src/parse.ts

@@ -583,6 +583,9 @@ export function postParseValidate(root: CliNode, pr: ParseResult): ParseResult {
 
   for (const d of defs) {
     if (d.required && !(d.name in opts)) {
+      if (d.kind === CliOptionKind.Json) {
+        continue;
+      }
       return errorResult(`Missing required option: --${d.name}`, pr.path);
     }
   }
@@ -592,6 +595,14 @@ export function postParseValidate(root: CliNode, pr: ParseResult): ParseResult {
     if (!d) {
       return errorResult(`Unknown option key: ${k}`, pr.path);
     }
+    if (d.kind === CliOptionKind.Json) {
+      try {
+        JSON.parse(v);
+      } catch {
+        return errorResult(`Invalid JSON for option --${k}`, pr.path);
+      }
+      continue;
+    }
     if (d.kind === CliOptionKind.Number) {
       if (!fullStringIsDouble(v)) {
         return errorResult(`Invalid number for option --${k}: ${v}`, pr.path);

package/src/types.ts

@@ -12,7 +12,7 @@ import type { CliContext } from "./context.ts";
 export type CliInvocation = "cli" | "mcp" | "api";
 
 /**
- * Option kinds: presence (boolean flag), string (free-form text), number (strict double), or enum (fixed choices).
+ * Option kinds: presence (boolean flag), string (free-form text), number (strict double), enum (fixed choices), or json (parsed JSON object/array).
  */
 export enum CliOptionKind {
   /** Boolean flag: no value token (may be implicit `"1"` when set). */
@@ -23,6 +23,8 @@ export enum CliOptionKind {
   Number = "number",
   /** Fixed set of allowed string values. Requires non-empty `choices` on the option. */
   Enum = "enum",
+  /** JSON object or array (parsed from `--name '<json>'`, piped stdin when `pipable`, or MCP/API tool body). */
+  Json = "json",
 }
 
 /**
@@ -89,6 +91,11 @@ export interface CliOption {
   default?: string;
   /** Regex pattern for string options. Mutually exclusive with `format`. */
   pattern?: string;
+  /**
+   * When `true` on a `Json` option, CLI may omit `--name` and supply JSON via stdin instead.
+   * If `--name` is set, the flag value wins and stdin is not read.
+   */
+  pipable?: boolean;
 }
 
 /**

package/src/validate.ts

@@ -247,6 +247,31 @@ function walkNode(node: CliNode, program: CliProgram, isRoot: boolean): void {
     if (resolved !== undefined && (typeof resolved !== "object" || resolved === null || Array.isArray(resolved))) {
       throw new CliSchemaValidationError("outputSchema must be a JSON Schema object (not null or an array)");
     }
+    const inputSchema = node.inputSchema;
+    if (
+      inputSchema !== undefined &&
+      (typeof inputSchema !== "object" || inputSchema === null || Array.isArray(inputSchema))
+    ) {
+      throw new CliSchemaValidationError("inputSchema must be a JSON Schema object (not null or an array)");
+    }
+    if (inputSchema !== undefined) {
+      const properties = inputSchema.properties;
+      if (
+        properties !== undefined &&
+        (typeof properties !== "object" || properties === null || Array.isArray(properties))
+      ) {
+        throw new CliSchemaValidationError(`inputSchema.properties must be an object on ${node.key}`);
+      }
+      if (properties) {
+        for (const opt of node.options ?? []) {
+          if (opt.kind === CliOptionKind.Json && !(opt.name in properties)) {
+            throw new CliSchemaValidationError(
+              `Json option '${opt.name}' is missing from inputSchema.properties on ${node.key}`,
+            );
+          }
+        }
+      }
+    }
   } else {
     const rogue = node as unknown as CliLeaf;
     if (rogue.mcpTool !== undefined) {
@@ -301,7 +326,22 @@ function walkNode(node: CliNode, program: CliProgram, isRoot: boolean): void {
 
 function validateOptions(scopeKey: string, options: import("./types.ts").CliOption[]): void {
   const seenShorts = new Set<string>();
+  let pipableCount = 0;
   for (const opt of options) {
+    if (opt.pipable) {
+      pipableCount++;
+      if (opt.kind !== CliOptionKind.Json) {
+        throw new CliSchemaValidationError(`pipable is only valid on Json kind: ${scopeKey}/${opt.name}`);
+      }
+    }
+    if (opt.kind === CliOptionKind.Json) {
+      if (opt.format !== undefined || opt.pattern !== undefined || opt.default !== undefined) {
+        throw new CliSchemaValidationError(
+          `Json option cannot use format, pattern, or default: ${scopeKey}/${opt.name}`,
+        );
+      }
+    }
+
     if (opt.required && opt.kind === CliOptionKind.Presence) {
       throw new CliSchemaValidationError(`Presence option cannot be required: ${scopeKey}/${opt.name}`);
     }
@@ -340,6 +380,9 @@ function validateOptions(scopeKey: string, options: import("./types.ts").CliOpti
       validateOptionValueMetadata(scopeKey, opt);
     }
   }
+  if (pipableCount > 1) {
+    throw new CliSchemaValidationError(`At most one pipable Json option per command: ${scopeKey}`);
+  }
 }
 
 function validateOptionValueMetadata(scopeKey: string, opt: import("./types.ts").CliOption): void {

package/examples/full-example/src/commands/status/schema.ts

@@ -1,14 +0,0 @@
-/** JSON stdout for `full-example status --json`. */
-export interface StatusJsonOutput {
-  /** Resolved AWS region. */
-  defaultRegion?: string;
-  /** Resolved retry count. */
-  maxRetries?: number;
-  /** Whether apiToken is set (value never included). */
-  apiTokenSet: boolean;
-  /** App version from program root. */
-  version: string;
-}
-
-/** Schemagen root for leaf outputSchema. */
-export type outputType = StatusJsonOutput;