@redocly/cli 2.71.2 → 2.72.0

package/lib/eject-assets/generators/java/descriptor.ts

@@ -0,0 +1,72 @@
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "java" generator.
+// This file is yours: edit freely; the generated client stays machine-owned and is
+// rebuilt by `redocly generate-client`. Newer generator versions merge in with
+// `redocly eject-generator java --update`.
+// The `descriptor` stage: the per-operation `Operation` literal — security
+// OR-alternatives and the pagination spec — and the envelope-header coerce specs.
+
+import {
+  type ApiModel,
+  headerCoerceType,
+  type NeutralPaginationRule,
+  type OperationModel,
+  securityRequirements,
+  uniqueIdentifiers,
+} from '@redocly/client-generator';
+
+import { JAVA, javaString } from './naming.ts';
+
+/** `List.of(List.of(SecuritySpec…))` for the operation's security OR-alternatives. */
+export function javaSecurityLiteral(op: OperationModel, model: ApiModel): string {
+  const alternatives = securityRequirements(op, model).map((alternative) => {
+    const specs = alternative.map((spec) =>
+      spec.kind === 'apiKey'
+        ? `new SecuritySpec(${javaString(spec.scheme)}, "apiKey", ${javaString(spec.name)}, ${javaString(spec.in)})`
+        : `SecuritySpec.of(${javaString(spec.scheme)}, ${javaString(spec.kind)})`
+    );
+    return `List.of(${specs.join(', ')})`;
+  });
+  return `List.of(${alternatives.join(', ')})`;
+}
+
+/** The neutral rule as a `new PaginationSpec(…)` literal, or `null` when the operation does not paginate. */
+export function javaPaginationLiteral(rule: NeutralPaginationRule | undefined): string {
+  if (rule === undefined) return 'null';
+  const field = (value: string | undefined) => (value === undefined ? 'null' : javaString(value));
+  return `new PaginationSpec(${[
+    javaString(rule.style),
+    field(rule.param),
+    field(rule.nextCursor),
+    field(rule.hasMore),
+    field(rule.nextLink),
+    field(rule.limitParam),
+    field(rule.items),
+  ].join(', ')})`;
+}
+
+/**
+ * The operation as the runtime describes it, built where it is used: a table of every
+ * operation in one static initializer would exceed the JVM's method size on a large
+ * description, and the record is a trivial allocation.
+ */
+export function javaOperationLiteral(
+  op: OperationModel,
+  model: ApiModel,
+  rule: NeutralPaginationRule | undefined
+): string {
+  return `new Operation(${javaString(op.specName ?? op.name)}, ${javaString(op.method.toUpperCase())}, ${javaString(op.path)}, ${javaSecurityLiteral(op, model)}, ${javaPaginationLiteral(rule)})`;
+}
+
+/** Declared response headers as runtime coerce specs: `{wire name, camelCase key, type}`. */
+export function envelopeHeaderSpecs(op: OperationModel, model: ApiModel): string {
+  const headers = op.successResponseHeaders ?? [];
+  const keys = uniqueIdentifiers(
+    headers.map((header) => header.name),
+    { style: 'camel', reserved: JAVA }
+  );
+  const specs = headers.map((header, index) => {
+    const type = headerCoerceType(header.schema, model);
+    return `{${javaString(header.name)}, ${javaString(keys[index])}, ${javaString(type)}}`;
+  });
+  return `new String[][] {${specs.join(', ')}}`;
+}

package/lib/eject-assets/generators/java/index.ts

@@ -0,0 +1,245 @@
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "java" generator.
+// This file is yours: edit freely; the generated client stays machine-owned and is
+// rebuilt by `redocly generate-client`. Newer generator versions merge in with
+// `redocly eject-generator java --update`.
+// The built-in `java` generator — the fourth non-TypeScript library entry, authored
+// with the language-neutral toolkit only (same dogfooding invariant as python/go/php,
+// pinned by the guard test). Output is one Java >= 17 file over java.net.http: a public
+// class named after the output stem that nests the records (with fromJson/toJson
+// hydration), wire-backed enums, sealed union interfaces, the embedded runtime, and one
+// typed method per operation. Exceptions are the error mode (`errorMode` does not apply).
+
+import {
+  type CodeSample,
+  type Generator,
+  identifierFor,
+  jsonSuccessSchema,
+  type NeutralPaginationRule,
+  type OperationModel,
+  renderReferencePage,
+  type SampleContext,
+  sseResponse,
+} from '@redocly/client-generator';
+import { JavaPrinter } from '@redocly/client-generator/printers/java';
+import { JAVA_RUNTIME_SOURCE } from '@redocly/client-generator/runtime-sources';
+import { logger } from '@redocly/openapi-core';
+
+import { writeServers } from './client.ts';
+import { writeJavaModels } from './models.ts';
+import {
+  JAVA,
+  javaClassName,
+  javaPackageName,
+  javaString,
+  methodIdents,
+  plainPackageName,
+} from './naming.ts';
+import { paramsClassName, writeJavaMethod, writeParamsClass } from './operations.ts';
+import { writeJavaPaginationWrappers } from './pagination.ts';
+import { javaType } from './types.ts';
+
+export { renderJavaModels } from './models.ts';
+export { javaType } from './types.ts';
+
+/** The `import` lines of the runtime, which the generated file declares for both of them. */
+function runtimeImports(): string[] {
+  return JAVA_RUNTIME_SOURCE.split('\n').filter((line) => line.startsWith('import '));
+}
+
+/**
+ * The runtime's class body — everything between its class line and its closing brace, at
+ * the one-level indent the generated class also uses — for inline embedding.
+ */
+function runtimeBody(): string[] {
+  const lines = JAVA_RUNTIME_SOURCE.split('\n');
+  const start = lines.findIndex((line) => line.startsWith('abstract class Runtime {'));
+  const end = lines.lastIndexOf('}');
+  return lines
+    .slice(start + 1, end)
+    .map((line) => (line.startsWith('    ') ? line.slice(4) : line));
+}
+
+/** The whole generated file: package, imports, and the class nesting models, runtime, and methods. */
+export const javaGenerator: Generator = ({ model, output, banner, emit, pagination }) => {
+  const printer = new JavaPrinter();
+  const dateType = emit.dateType ?? 'string';
+  const className = javaClassName(output.stem, model);
+  const packageName = javaPackageName(model.title);
+  // A package the reader cannot see in the title would surprise the code that imports it.
+  if (packageName !== plainPackageName(model.title)) {
+    logger.warn(
+      `generate-client: the API title ${JSON.stringify(model.title)} cannot be a Java package as is, so the java SDK uses package "${packageName}" — rename the API title in the description to choose another.\n`
+    );
+  }
+  const moduleRuntime = emit.runtime === 'module';
+  const runtimeClass = `${className}Runtime`;
+  const operations = model.services.flatMap((service) => service.operations);
+  const idents = methodIdents(model);
+  // Pagination arrives RESOLVED from the pipeline — one fit-verified answer per run.
+  const paginationRules = new Map<string, NeutralPaginationRule>();
+  for (const op of operations) {
+    const spec = pagination?.get(op.name)?.spec;
+    if (spec !== undefined) paginationRules.set(op.name, spec);
+  }
+
+  printer.line(
+    `// Code generated by @redocly/client-generator (java) from ${javaString(model.title)} ${model.version}. DO NOT EDIT.`
+  );
+  printer.line(
+    '// Regenerate with `redocly generate-client`. Java >= 17, standard library only — zero dependencies.'
+  );
+  printer.blank();
+  printer.line(`package ${packageName};`);
+  printer.blank();
+  for (const line of runtimeImports()) printer.line(line);
+  printer.blank();
+  printer.doc(className, `Client for ${model.title} (${model.version}).`);
+  printer.block(
+    `public final class ${className}${moduleRuntime ? ` extends ${runtimeClass}` : ''} {`,
+    () => {
+      writeJavaModels(printer, model, dateType);
+      writeServers(printer, model);
+      if (!moduleRuntime) {
+        printer.line('// ─── Embedded runtime (@redocly/client-generator java runtime) ───');
+        for (const line of runtimeBody()) printer.line(line);
+        printer.blank();
+      }
+      for (const op of operations) {
+        writeParamsClass(printer, op, idents.get(op.name)!, model, dateType);
+      }
+      printer.line('private final Config config;');
+      printer.blank();
+      printer.block(
+        `public ${className}(Config config) {`,
+        () => {
+          printer.line('this.config = config;');
+          printer.block(
+            'if (config.serverUrl.isEmpty()) {',
+            () => {
+              printer.line(
+                `config.serverUrl = ${javaString(emit.serverUrl ?? model.serverUrl ?? '')};`
+              );
+            },
+            '}'
+          );
+        },
+        '}'
+      );
+      printer.blank();
+      printer.block(
+        `public ${className}() {`,
+        () => {
+          printer.line('this(new Config());');
+        },
+        '}'
+      );
+      printer.blank();
+
+      for (const op of operations) {
+        const ident = idents.get(op.name)!;
+        const rule = paginationRules.get(op.name);
+        writeJavaMethod(printer, op, ident, model, dateType, rule);
+        if (sseResponse(op) === undefined && (op.successResponseHeaders?.length ?? 0) > 0) {
+          writeJavaMethod(printer, op, ident, model, dateType, rule, true);
+        }
+        if (rule !== undefined) {
+          writeJavaPaginationWrappers(printer, op, ident, model, dateType, rule);
+        }
+      }
+    },
+    '}'
+  );
+
+  const entry = {
+    path: output.path.replace(/[^\\/]+$/, `${className}.java`),
+    content: printer.toString(),
+  };
+  if (!moduleRuntime) return [entry];
+  // The runtime as a real file: the same source, as a public base class the client extends,
+  // so every runtime name resolves unqualified in both runtime modes.
+  const header = banner.map((line) => `// ${line}`).join('\n');
+  const runtimeSource = JAVA_RUNTIME_SOURCE.replace(
+    /^abstract class Runtime \{$/m,
+    `public abstract class ${runtimeClass} {`
+  );
+  return [
+    entry,
+    {
+      path: output.path.replace(/[^\\/]+$/, `${runtimeClass}.java`),
+      content: `${header}\npackage ${packageName};\n\n${runtimeSource
+        .replace(/^\/\/.*\n/gm, '')
+        .trimStart()
+        .trimEnd()}\n`,
+    },
+  ];
+};
+
+/** One idiomatic Java call per operation — feeds `x-codeSamples` for docs. */
+export function javaSample(op: OperationModel, ctx: SampleContext): CodeSample {
+  const dateType = ctx.emit.dateType ?? 'string';
+  const stem = ctx.outputPath.replace(/^.*[\\/]/, '').replace(/\.[^.]+$/, '');
+  const className = javaClassName(stem, ctx.model);
+  const ident = methodIdents(ctx.model).get(op.name) ?? identifierFor(op.name, { reserved: JAVA });
+  const args = [
+    ...op.pathParams.map((param) =>
+      javaString(`<${identifierFor(param.name, { reserved: JAVA })}>`)
+    ),
+    ...(op.requestBody ? ['body'] : []),
+    ...(paramsClassName(op, ident, ctx.model) === undefined
+      ? []
+      : [`new ${className}.${paramsClassName(op, ident, ctx.model)}()`]),
+  ];
+  const call = `client.${ident}(${args.join(', ')})`;
+  // The statement matches the return shape: a void method has no result, an SSE method is
+  // iterated, and a typed method binds its result.
+  const statement =
+    sseResponse(op) !== undefined
+      ? `for (var event : ${call}) {\n    System.out.println(event.data());\n}`
+      : jsonSuccessSchema(op) === undefined
+        ? `${call};`
+        : `${javaType(jsonSuccessSchema(op)!, ctx.model, dateType)} result = ${call};`;
+  // The import names the package this run writes, so the snippet compiles as shown.
+  return {
+    lang: 'java',
+    label: 'Java SDK',
+    source: `import ${javaPackageName(ctx.model.title)}.${className};\n\n${className} client = new ${className}(new ${className}.Config());\n${statement}\n`,
+  };
+}
+
+/**
+ * The SDK's own reference page, written when `client.docs` is on. The call snippets come
+ * from `javaSample` — this generator's own hook — so the page can only ever show the syntax
+ * of the SDK beside it, and ejecting this generator takes the page with it.
+ */
+export const javaDocs: Generator = ({ model, output, emit, pagination }) => [
+  {
+    path: output.path.replace(/\.[^.\\/]+$/, '.java.md'),
+    content: renderReferencePage(model, {
+      title: `${model.title} Java SDK reference`,
+      frontmatter: emit.docsFrontmatter === true,
+      language: {
+        name: 'java',
+        label: 'Java',
+        fence: 'java',
+        requires: 'The SDK needs Java 17 or newer and the standard library only.',
+      },
+      sample: (op) => javaSample(op, { model, emit, outputPath: output.path }),
+      paginated: new Set(pagination?.keys() ?? []),
+    }),
+  },
+];
+
+export default {
+  name: 'java',
+  run: javaGenerator,
+  sample: javaSample,
+  docs: javaDocs,
+  errorModes: ["throw"],
+  notApplicable: {
+    "outputMode": "it always emits one self-contained file",
+    "runtime": "the runtime is always embedded in the generated file",
+    "argsStyle": "inputs follow the target language's own idiom",
+    "importExt": "the generated file has no relative imports"
+  },
+  requiresGenerator: '^0.8.0',
+};

package/lib/eject-assets/generators/java/models.ts

@@ -0,0 +1,362 @@
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "java" generator.
+// This file is yours: edit freely; the generated client stays machine-owned and is
+// rebuilt by `redocly generate-client`. Newer generator versions merge in with
+// `redocly eject-generator java --update`.
+// The `models` stage: named schemas as records with fromJson/toJson hydration,
+// wire-backed enums, and sealed union interfaces with a parse dispatcher — plus the
+// wire→typed value expressions the methods reuse.
+
+import {
+  type ApiModel,
+  type DateType,
+  deref,
+  discriminatorCases,
+  enumValues,
+  flattenAllOf,
+  type PropertyModel,
+  type SchemaModel,
+  uniqueIdentifiers,
+  unwrapNullable,
+} from '@redocly/client-generator';
+import { JavaPrinter } from '@redocly/client-generator/printers/java';
+
+import { JAVA, javaString, typeName } from './naming.ts';
+import { classify, isDateFormat, javaType } from './types.ts';
+
+/**
+ * Wire value → typed value expression over the runtime's JSON graph, or undefined when
+ * the raw `Object` is already the type. `depth` names the lambda parameters of nested
+ * collections (`item`, `item2`, …): Java rejects a lambda parameter that shadows one.
+ */
+export function hydration(
+  schema: SchemaModel,
+  expr: string,
+  model: ApiModel,
+  // Required on purpose: a defaulted `'string'` let a call site forget it, and the method
+  // then returned a raw string where its own signature declared `OffsetDateTime`.
+  dateType: DateType,
+  depth = 0
+): string | undefined {
+  const bare = unwrapNullable(schema);
+  switch (bare.kind) {
+    case 'scalar':
+      if (dateType === 'Date' && bare.scalar === 'string' && isDateFormat(bare)) {
+        return bare.metadata?.format === 'date'
+          ? `asLocalDate(${expr})`
+          : `asOffsetDateTime(${expr})`;
+      }
+      return `${SCALAR_READERS[bare.scalar]}(${expr})`;
+    case 'enum':
+      return `${SCALAR_READERS[bare.scalar]}(${expr})`;
+    case 'literal':
+      return `${SCALAR_READERS[typeof bare.value === 'string' ? 'string' : typeof bare.value === 'boolean' ? 'boolean' : 'number']}(${expr})`;
+    case 'omit':
+      return hydration({ kind: 'ref', name: bare.base }, expr, model, dateType, depth);
+    case 'ref': {
+      const kind = classify(bare.name, model);
+      if (kind === 'record') return `${typeName(bare.name)}.fromJson(${expr})`;
+      if (kind === 'enum') {
+        const reader = enumValues(deref(bare, model)!)!.scalar === 'string' ? 'asString' : 'asLong';
+        return `${typeName(bare.name)}.fromWire(${reader}(${expr}))`;
+      }
+      if (kind === 'union') return `parse${typeName(bare.name)}(${expr})`;
+      const target = deref(bare, model);
+      return target === undefined ? undefined : hydration(target, expr, model, dateType, depth);
+    }
+    case 'array':
+    case 'record': {
+      const item = depth === 0 ? 'item' : `item${depth + 1}`;
+      const inner =
+        hydration(
+          bare.kind === 'array' ? bare.items : bare.value,
+          item,
+          model,
+          dateType,
+          depth + 1
+        ) ?? item;
+      return `${bare.kind === 'array' ? 'asList' : 'asMap'}(${expr}, ${item} -> ${inner})`;
+    }
+    case 'union':
+    case 'null':
+    case 'object':
+    case 'intersection':
+    case 'unknown':
+      return undefined;
+  }
+}
+
+const SCALAR_READERS = {
+  string: 'asString',
+  integer: 'asLong',
+  number: 'asDouble',
+  boolean: 'asBoolean',
+};
+
+/** The record components may not collide with the record's own methods or the locals of fromJson/toJson. */
+// prettier-ignore
+const RECORD_MEMBER_SLOTS = [
+  'data', 'json', 'toJson', 'fromJson', 'hashCode', 'equals', 'toString', 'getClass', 'wait',
+  'notify', 'notifyAll', 'clone', 'finalize',
+];
+
+/** The sealed unions a record is a member of, so it declares `implements` for each. */
+function unionsOf(name: string, model: ApiModel): string[] {
+  const unions: string[] = [];
+  for (const candidate of model.schemas) {
+    if (classify(candidate.name, model) !== 'union') continue;
+    const cases = discriminatorCases(candidate.schema, model)!;
+    if (cases.cases.some((entry) => entry.schemaName === name)) {
+      unions.push(typeName(candidate.name));
+    }
+  }
+  return unions;
+}
+
+function writeRecord(
+  printer: JavaPrinter,
+  name: string,
+  properties: PropertyModel[],
+  model: ApiModel,
+  dateType: DateType,
+  description?: string
+): void {
+  // A response never carries a `writeOnly` property, and responses decode into this same
+  // record, so the property is optional even when the description requires it.
+  const fields = properties.map((property) =>
+    property.writeOnly ? { ...property, required: false } : property
+  );
+  const components = uniqueIdentifiers(
+    fields.map((property) => property.name),
+    { style: 'camel', reserved: JAVA, taken: RECORD_MEMBER_SLOTS }
+  );
+  const record = typeName(name);
+  const interfaces = ['JsonValue', ...unionsOf(name, model)];
+  printer.doc(record, description);
+  printer.block(
+    `public record ${record}(`,
+    () => {
+      fields.forEach((property, index) => {
+        const comma = index < fields.length - 1 ? ',' : '';
+        printer.line(`${javaType(property.schema, model, dateType)} ${components[index]}${comma}`);
+      });
+    },
+    `) implements ${interfaces.join(', ')} {`
+  );
+  printer.indent(() => {
+    printer.block(
+      `public static ${record} fromJson(Object json) {`,
+      () => {
+        printer.line('Map<String, Object> data = asObject(json);');
+        printer.block(
+          'if (data == null) {',
+          () => {
+            printer.line('return null;');
+          },
+          '}'
+        );
+        printer.block(
+          `return new ${record}(`,
+          () => {
+            fields.forEach((property, index) => {
+              const raw = `data.get(${javaString(property.name)})`;
+              const comma = index < fields.length - 1 ? ',' : '';
+              printer.line(`${hydration(property.schema, raw, model, dateType) ?? raw}${comma}`);
+            });
+          },
+          ');'
+        );
+      },
+      '}'
+    );
+    printer.blank();
+    printer.line('@Override');
+    printer.block(
+      'public Map<String, Object> toJson() {',
+      () => {
+        printer.line('Map<String, Object> data = new LinkedHashMap<>();');
+        fields.forEach((property, index) => {
+          const put = `data.put(${javaString(property.name)}, ${components[index]});`;
+          if (property.required) {
+            printer.line(put);
+          } else {
+            printer.block(
+              `if (${components[index]} != null) {`,
+              () => {
+                printer.line(put);
+              },
+              '}'
+            );
+          }
+        });
+        printer.line('return data;');
+      },
+      '}'
+    );
+  });
+  printer.line('}');
+  printer.blank();
+}
+
+function writeEnum(
+  printer: JavaPrinter,
+  name: string,
+  values: Array<string | number | boolean>,
+  scalar: 'string' | 'integer',
+  description?: string
+): void {
+  const enumName = typeName(name);
+  const wireType = scalar === 'string' ? 'String' : 'Long';
+  const members = enumValues({ kind: 'enum', values, scalar })!.memberNames;
+  printer.doc(enumName, description);
+  printer.block(
+    `public enum ${enumName} implements WireValue {`,
+    () => {
+      values.forEach((value, index) => {
+        const literal = typeof value === 'string' ? javaString(value) : `${value}L`;
+        printer.line(`${members[index]}(${literal})${index < values.length - 1 ? ',' : ';'}`);
+      });
+      printer.blank();
+      printer.line(`private final ${wireType} wire;`);
+      printer.blank();
+      printer.block(
+        `${enumName}(${wireType} wire) {`,
+        () => {
+          printer.line('this.wire = wire;');
+        },
+        '}'
+      );
+      printer.blank();
+      printer.line('@Override');
+      printer.block(
+        `public ${wireType} wire() {`,
+        () => {
+          printer.line('return wire;');
+        },
+        '}'
+      );
+      printer.blank();
+      printer.line(
+        '/** The member for a wire value; null for null, an exception for an unknown value. */'
+      );
+      printer.block(
+        `public static ${enumName} fromWire(${wireType} wire) {`,
+        () => {
+          printer.block(
+            'if (wire == null) {',
+            () => {
+              printer.line('return null;');
+            },
+            '}'
+          );
+          printer.block(
+            `for (${enumName} member : values()) {`,
+            () => {
+              printer.block(
+                'if (member.wire.equals(wire)) {',
+                () => {
+                  printer.line('return member;');
+                },
+                '}'
+              );
+            },
+            '}'
+          );
+          printer.line(`throw new IllegalArgumentException("Unknown ${enumName} value: " + wire);`);
+        },
+        '}'
+      );
+    },
+    '}'
+  );
+  printer.blank();
+}
+
+/** Write every named schema at the printer's current depth: records, enums, union dispatchers. */
+export function writeJavaModels(
+  printer: JavaPrinter,
+  model: ApiModel,
+  dateType: DateType = 'string'
+): void {
+  for (const { name, schema } of model.schemas) {
+    const asEnum = enumValues(schema);
+    if (asEnum !== undefined && (asEnum.scalar === 'string' || asEnum.scalar === 'integer')) {
+      writeEnum(printer, name, asEnum.values, asEnum.scalar, schema.description);
+      continue;
+    }
+    if (schema.kind === 'object' || schema.kind === 'intersection') {
+      const flat = flattenAllOf(schema, model);
+      if (flat !== undefined) {
+        writeRecord(
+          printer,
+          name,
+          flat.properties,
+          model,
+          dateType,
+          flat.description ?? schema.description
+        );
+        continue;
+      }
+    }
+    const cases = discriminatorCases(schema, model);
+    if (cases !== undefined) {
+      const union = typeName(name);
+      const sealed = classify(name, model) === 'union';
+      const table = cases.cases
+        .map((entry) => `${entry.value} -> ${typeName(entry.schemaName)}`)
+        .join(', ');
+      // The table carries the description's own values, so it goes through the comment escaper.
+      printer.doc(union, `A discriminated union on ${javaString(cases.property)}: ${table}.`);
+      if (sealed) {
+        // The permitted records sit in the same compilation unit, so `permits` is implied.
+        printer.line(`public sealed interface ${union} extends JsonValue {}`);
+        printer.blank();
+      }
+      // A target without a record of its own keeps the raw value, so the union is `Object`.
+      printer.block(
+        `public static ${sealed ? union : 'Object'} parse${union}(Object json) {`,
+        () => {
+          printer.line('Map<String, Object> data = asObject(json);');
+          printer.block(
+            'if (data == null) {',
+            () => {
+              printer.line('return null;');
+            },
+            '}'
+          );
+          printer.block(
+            `switch (String.valueOf(data.get(${javaString(cases.property)}))) {`,
+            () => {
+              for (const entry of cases.cases) {
+                const target = { kind: 'ref', name: entry.schemaName } as const;
+                const typed = hydration(target, 'data', model, dateType) ?? 'data';
+                printer.line(`case ${javaString(entry.value)}:`);
+                printer.indent(() => printer.line(`return ${typed};`));
+              }
+              printer.line('default:');
+              printer.indent(() =>
+                printer.line(
+                  sealed
+                    ? `throw new IllegalArgumentException("Unknown ${cases.property} value: " + data.get(${javaString(cases.property)}));`
+                    : 'return data;'
+                )
+              );
+            },
+            '}'
+          );
+        },
+        '}'
+      );
+      printer.blank();
+      continue;
+    }
+    // Everything else (plain unions, aliases, records) has no Java declaration;
+    // references resolve to the underlying type via javaType.
+  }
+}
+
+/** Render every named schema at depth 0 — the models section on its own, for the render bars. */
+export function renderJavaModels(model: ApiModel, dateType: DateType = 'string'): string {
+  const printer = new JavaPrinter();
+  writeJavaModels(printer, model, dateType);
+  return printer.toString();
+}