@redocly/cli 2.71.1 → 2.72.0

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

@@ -0,0 +1,135 @@
+// 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 `naming` stage: the shared printer/naming instance, the string escaper, the
+// enclosing class name, and the collision-free type/member/method identifiers every
+// other stage builds on.
+
+import {
+  type ApiModel,
+  casing,
+  identifierFor,
+  NotSupportedError,
+  type OperationModel,
+  RESERVED_WORDS,
+} from '@redocly/client-generator';
+import { JavaPrinter } from '@redocly/client-generator/printers/java';
+import { JAVA_RUNTIME_SOURCE } from '@redocly/client-generator/runtime-sources';
+
+export const JAVA = RESERVED_WORDS.java;
+
+// Naming and escaping delegate to the printer — one implementation, one policy.
+export const naming = new JavaPrinter();
+
+/**
+ * The type names the runtime already uses inside the generated class — its own nested
+ * types and every JDK type it references, read off its source — plus the names the
+ * generated methods add. A schema that folds to one of them gets a `Model` suffix: a
+ * nested `record Config` would shadow the runtime's `Config`, and a nested `record Thread`
+ * (GitHub has one) would shadow `java.lang.Thread` for the runtime's retry sleep.
+ */
+const TAKEN_TYPE_NAMES = new Set([
+  ...[
+    // Comments, char literals (a `'"'` would otherwise open a string), then strings go.
+    ...JAVA_RUNTIME_SOURCE.replace(/\/\*[\s\S]*?\*\/|\/\/.*$/gm, '')
+      .replace(/'(?:[^'\\]|\\.)'/g, "''")
+      .replace(/"(?:[^"\\]|\\.)*"/g, '""')
+      .matchAll(/\b[A-Z][A-Za-z0-9]*\b/g),
+  ].map((match) => match[0]),
+  'Servers',
+  'Void',
+]);
+
+export function typeName(name: string): string {
+  const ident = naming.typeName(name);
+  return TAKEN_TYPE_NAMES.has(ident) ? `${ident}Model` : ident;
+}
+
+export function memberName(name: string): string {
+  return naming.memberName(name);
+}
+
+/** `"…"` with the escapes javac needs — safe for any spec-supplied text. */
+export function javaString(value: string): string {
+  return naming.string(value);
+}
+
+/**
+ * The enclosing class — Java puts one public class per file, named after it — derived
+ * from the `--output` stem the way Python derives its module name (`openapi.client` →
+ * `OpenapiClient`). A schema of the same name cannot nest inside it, so that is rejected
+ * with the fix rather than renamed behind the user's back.
+ */
+export function javaClassName(stem: string, model: ApiModel): string {
+  const name = identifierFor(stem, { style: 'pascal', reserved: JAVA });
+  // Inside a class named `Config` or `List`, those names mean the class itself.
+  if (TAKEN_TYPE_NAMES.has(name)) {
+    throw new NotSupportedError(
+      `The output file name "${stem}" gives the Java class the name "${name}", which the SDK already uses for one of its own types. Choose another --output name, for example "${stem}-sdk.ts".`
+    );
+  }
+  const clash = model.schemas.find((schema) => typeName(schema.name) === name);
+  if (clash !== undefined) {
+    throw new NotSupportedError(
+      `The output file name "${stem}" gives the Java class the same name as the "${clash.name}" schema, which cannot nest inside it. Choose another --output name, for example "${stem}-sdk.ts".`
+    );
+  }
+  return name;
+}
+
+/**
+ * The package clause the output declares, derived from the API title the way the PHP
+ * generator derives its namespace: the title's words in lowercase, run together, as Java
+ * package names are written (`Cafe Orders API` → `cafeordersapi`). A class in the default
+ * package cannot be imported from any named package, so there is always one. A name that
+ * cannot be a package as is follows Oracle's package-naming convention: a keyword gets a
+ * trailing underscore (`class_`), and so does `java`, which the JVM keeps for the JDK; a
+ * leading digit gets a leading underscore (`_3dprintingapi`).
+ */
+export function javaPackageName(title: string): string {
+  const plain = plainPackageName(title);
+  if (plain === '') return 'api';
+  if (/^[0-9]/.test(plain)) return `_${plain}`;
+  return JAVA.has(plain) || plain === 'java' ? `${plain}_` : plain;
+}
+
+/** The title's words in lowercase, run together — the package before any convention applies. */
+export function plainPackageName(title: string): string {
+  return casing.pascal(title).toLowerCase();
+}
+
+export function methodName(op: OperationModel): string {
+  return identifierFor(op.name, { style: 'camel', reserved: JAVA });
+}
+
+/** The methods every class inherits from `Object`; an operation named after one would override it. */
+// prettier-ignore
+const OBJECT_METHODS = [
+  'getClass', 'hashCode', 'equals', 'clone', 'toString', 'notify', 'notifyAll', 'wait',
+  'finalize',
+];
+
+/** The methods an operation may add beside its own, all named after it. */
+const METHOD_VARIANTS = ['', 'WithHeaders', 'Pages', 'Items'];
+
+/**
+ * The method name for every operation, unique across the client — two operationIds may
+ * camel-case to one name (`get-user`, `getUser`). Each name also books its `WithHeaders`,
+ * `Pages`, and `Items` variants, so a later operation named like one of them moves aside
+ * (`listOrdersPages2`). Keyed by the IR name, which the sanitizer already made unique.
+ */
+export function methodIdents(model: ApiModel): Map<string, string> {
+  const used = new Set(OBJECT_METHODS);
+  const idents = new Map<string, string>();
+  for (const op of model.services.flatMap((service) => service.operations)) {
+    const base = identifierFor(op.name, { style: 'camel', reserved: JAVA });
+    let ident = base;
+    for (let suffix = 2; METHOD_VARIANTS.some((variant) => used.has(ident + variant)); suffix++) {
+      ident = `${base}${suffix}`;
+    }
+    for (const variant of METHOD_VARIANTS) used.add(ident + variant);
+    idents.set(op.name, ident);
+  }
+  return idents;
+}

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

@@ -0,0 +1,300 @@
+// 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 `operations` stage: one typed request method per operation, the `<Op>Params`
+// class its optional query parameters travel in, and the argument planning and request
+// prologue it shares with the pagination wrappers.
+
+import {
+  type ApiModel,
+  type DateType,
+  deref,
+  isBinaryContentType,
+  isMultipartBody,
+  isUntypedMultipartBody,
+  jsonSuccessSchema,
+  type NeutralPaginationRule,
+  type OperationModel,
+  sseResponse,
+  uniqueIdentifiers,
+  unwrapNullable,
+} from '@redocly/client-generator';
+import type { JavaPrinter } from '@redocly/client-generator/printers/java';
+
+import { envelopeHeaderSpecs, javaOperationLiteral } from './descriptor.ts';
+import { hydration } from './models.ts';
+import { JAVA, javaString, typeName } from './naming.ts';
+import { javaType } from './types.ts';
+
+type MethodArgs = {
+  pathArgs: Array<{ java: string; wire: string }>;
+  /** The optional query parameters, as fields of the `<Op>Params` class. */
+  queryFields: Array<{ java: string; wire: string; type: string; isArray: boolean }>;
+  paramsClass: string | undefined;
+  signature: string[];
+};
+
+/**
+ * The argument and local names a request method declares beside its path parameters. A
+ * parameter named after one of them takes a suffixed name instead, so each keeps its meaning.
+ */
+// prettier-ignore
+const METHOD_ARG_SLOTS = [
+  'body', 'params', 'op', 'auth', 'query', 'url', 'spec', 'payload', 'response', 'data',
+  'headers', 'extraHeaders', 'pageParams', 'call', 'base', 'item', 'page', 'config',
+];
+
+/** Whether the body is `Object` and the runtime sorts out what it got (`multipartBody` / `binaryBody`). */
+function passesThrough(op: OperationModel): boolean {
+  return (
+    isUntypedMultipartBody(op) ||
+    (op.requestBody !== undefined && isBinaryContentType(op.requestBody.contentType))
+  );
+}
+
+/**
+ * The `<Op>Params` class name, when the operation has query parameters. A schema may fold
+ * to the same name (`ListOrdersParams` is a plausible schema), and two nested classes cannot
+ * share one, so the class moves aside with a suffix.
+ */
+export function paramsClassName(
+  op: OperationModel,
+  ident: string,
+  model: ApiModel
+): string | undefined {
+  if (op.queryParams.length === 0) return undefined;
+  return uniqueIdentifiers([`${ident}Params`], {
+    style: 'pascal',
+    reserved: JAVA,
+    taken: model.schemas.map((schema) => typeName(schema.name)),
+  })[0];
+}
+
+export function methodArgs(
+  op: OperationModel,
+  ident: string,
+  model: ApiModel,
+  includeBody: boolean,
+  dateType: DateType
+): MethodArgs {
+  // Path parameters are arguments, so their names share one namespace with the locals the
+  // method declares itself; a repeat moves aside (`body`, `body2`). Query parameters live in
+  // their own class, so they only need to be unique among themselves.
+  const pathNames = uniqueIdentifiers(
+    op.pathParams.map((param) => param.name),
+    { style: 'camel', reserved: JAVA, taken: METHOD_ARG_SLOTS }
+  );
+  const queryNames = uniqueIdentifiers(
+    op.queryParams.map((param) => param.name),
+    { style: 'camel', reserved: JAVA }
+  );
+  const pathArgs = op.pathParams.map((param, index) => ({
+    java: pathNames[index],
+    wire: param.name,
+  }));
+  const queryFields = op.queryParams.map((param, index) => ({
+    java: queryNames[index],
+    wire: param.name,
+    type: javaType(param.schema, model, dateType),
+    // Through a `$ref`: a named list alias repeats the key like an inline array does.
+    isArray: deref(unwrapNullable(param.schema), model)?.kind === 'array',
+  }));
+  const paramsClass = paramsClassName(op, ident, model);
+  const signature = [
+    ...op.pathParams.map(
+      (param, index) => `${javaType(param.schema, model, dateType)} ${pathNames[index]}`
+    ),
+    ...(includeBody && op.requestBody
+      ? [`${passesThrough(op) ? 'Object' : javaType(op.requestBody.schema, model, dateType)} body`]
+      : []),
+    ...(paramsClass === undefined ? [] : [`${paramsClass} params`]),
+  ];
+  return { pathArgs, queryFields, paramsClass, signature };
+}
+
+/** The `<Op>Params` class: one nullable field per query parameter, with a fluent setter each. */
+export function writeParamsClass(
+  printer: JavaPrinter,
+  op: OperationModel,
+  ident: string,
+  model: ApiModel,
+  dateType: DateType
+): void {
+  const { queryFields, paramsClass } = methodArgs(op, ident, model, false, dateType);
+  if (paramsClass === undefined) return;
+  printer.line(`/** The query parameters of ${ident}; an unset field is not sent. */`);
+  printer.block(
+    `public static final class ${paramsClass} {`,
+    () => {
+      for (const field of queryFields) printer.line(`public ${field.type} ${field.java};`);
+      for (const field of queryFields) {
+        printer.blank();
+        printer.block(
+          `public ${paramsClass} ${field.java}(${field.type} ${field.java}) {`,
+          () => {
+            printer.line(`this.${field.java} = ${field.java};`);
+            printer.line('return this;');
+          },
+          '}'
+        );
+      }
+    },
+    '}'
+  );
+  printer.blank();
+}
+
+/** Add the set query parameters to `target` (a `Map<String, List<String>>`). */
+export function writeQueryParams(printer: JavaPrinter, args: MethodArgs, target: string): void {
+  if (args.paramsClass === undefined) return;
+  printer.block(
+    'if (params != null) {',
+    () => {
+      for (const field of args.queryFields) {
+        printer.block(
+          `if (params.${field.java} != null) {`,
+          () => {
+            // An array repeats the key per element (OpenAPI `form` + `explode`, the default).
+            if (field.isArray) {
+              printer.block(
+                `for (Object item : params.${field.java}) {`,
+                () => {
+                  printer.line(`addQuery(${target}, ${javaString(field.wire)}, item);`);
+                },
+                '}'
+              );
+            } else {
+              printer.line(`addQuery(${target}, ${javaString(field.wire)}, params.${field.java});`);
+            }
+          },
+          '}'
+        );
+      }
+    },
+    '}'
+  );
+}
+
+/** The `buildUrl(…)` expression for the operation's path. */
+export function urlExpression(args: MethodArgs): string {
+  const pairs = args.pathArgs
+    .map(({ java, wire }) => `${javaString(wire)}, textValue(${java})`)
+    .join(', ');
+  return `buildUrl(config.serverUrl, op.path(), pathParams(${pairs}))`;
+}
+
+export function writeJavaMethod(
+  printer: JavaPrinter,
+  op: OperationModel,
+  ident: string,
+  model: ApiModel,
+  dateType: DateType,
+  rule: NeutralPaginationRule | undefined,
+  envelope = false
+): void {
+  const args = methodArgs(op, ident, model, true, dateType);
+  const sse = sseResponse(op);
+  const success = jsonSuccessSchema(op);
+  // Non-JSON success bodies (PDFs, images, octet streams) return the raw bytes.
+  const rawBody =
+    sse === undefined &&
+    success === undefined &&
+    op.successResponses.some((response) => response.contentType !== '');
+  const dataType =
+    success !== undefined ? javaType(success, model, dateType) : rawBody ? 'byte[]' : 'void';
+  const returnType = envelope
+    ? `Envelope<${dataType === 'void' ? 'Void' : dataType}>`
+    : sse !== undefined
+      ? 'Iterable<ServerSentEvent>'
+      : dataType;
+  const name = envelope ? `${ident}WithHeaders` : ident;
+  printer.doc(
+    name,
+    envelope
+      ? `Like ${ident}, returning an Envelope with the declared response headers.`
+      : (op.summary ?? `${op.method.toUpperCase()} ${op.path}`)
+  );
+  printer.block(
+    `public ${returnType} ${name}(${args.signature.join(', ')}) {`,
+    () => {
+      printer.line(`Operation op = ${javaOperationLiteral(op, model, rule)};`);
+      if (sse !== undefined) {
+        // Auth resolves inside the opener, so every reconnect asks a token supplier again
+        // — a long-lived stream outlives the token it started with.
+        const jsonData = sse.schema !== undefined && sse.schema.kind !== 'unknown';
+        printer.line('Map<String, List<String>> base = new LinkedHashMap<>();');
+        writeQueryParams(printer, args, 'base');
+        printer.line(`String url = ${urlExpression(args)};`);
+        printer.block(
+          'return iterSse(extraHeaders -> {',
+          () => {
+            printer.line('ResolvedAuth auth = resolveAuth(op.security(), config.auth);');
+            printer.line('Map<String, List<String>> query = cloneQuery(auth.query());');
+            printer.line('query.putAll(base);');
+            printer.line('Map<String, String> headers = new LinkedHashMap<>(auth.headers());');
+            printer.line('headers.putAll(extraHeaders);');
+            printer.line(
+              'return send(config, new RequestSpec(op.id(), op.method(), url).headers(headers).query(query));'
+            );
+          },
+          `}, ${jsonData});`
+        );
+        return;
+      }
+      printer.line('ResolvedAuth auth = resolveAuth(op.security(), config.auth);');
+      printer.line('Map<String, List<String>> query = auth.query();');
+      writeQueryParams(printer, args, 'query');
+      printer.line(`String url = ${urlExpression(args)};`);
+      printer.line(
+        'RequestSpec spec = new RequestSpec(op.id(), op.method(), url).headers(auth.headers()).query(query);'
+      );
+      if (op.requestBody !== undefined) {
+        const contentType = javaString(op.requestBody.contentType);
+        const payload = isUntypedMultipartBody(op)
+          ? 'multipartBody(body)'
+          : passesThrough(op)
+            ? `binaryBody(body, ${contentType})`
+            : isMultipartBody(op)
+              ? 'multipartBody(body)'
+              : `jsonBody(body, ${contentType})`;
+        printer.line(`Body payload = ${payload};`);
+        printer.line('spec.body(payload.body(), payload.contentType());');
+      }
+      printer.line('HttpResponse<InputStream> response = send(config, spec);');
+      printer.block(
+        'if (response.statusCode() >= 400) {',
+        () => {
+          printer.line('throw apiErrorFrom(response, url);');
+        },
+        '}'
+      );
+      const decoded = rawBody
+        ? 'readBody(response)'
+        : success === undefined
+          ? undefined
+          : (hydration(success, 'decodeJson(response)', model, dateType) ?? 'decodeJson(response)');
+      if (envelope) {
+        if (decoded === undefined) {
+          printer.line('readBody(response);');
+          printer.line(
+            `return new Envelope<>(null, readEnvelopeHeaders(response, ${envelopeHeaderSpecs(op, model)}), response.statusCode());`
+          );
+        } else {
+          printer.line(`${dataType} data = ${decoded};`);
+          printer.line(
+            `return new Envelope<>(data, readEnvelopeHeaders(response, ${envelopeHeaderSpecs(op, model)}), response.statusCode());`
+          );
+        }
+        return;
+      }
+      if (decoded === undefined) {
+        printer.line('readBody(response);');
+        return;
+      }
+      printer.line(`return ${decoded};`);
+    },
+    '}'
+  );
+  printer.blank();
+}

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

@@ -0,0 +1,94 @@
+// 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 `pagination` stage: the `<op>Pages()` / `<op>Items()` iterables over the
+// runtime's iterPages.
+
+import {
+  type ApiModel,
+  type DateType,
+  jsonSuccessSchema,
+  type NeutralPaginationRule,
+  type OperationModel,
+  paginationItemSchema,
+} from '@redocly/client-generator';
+import type { JavaPrinter } from '@redocly/client-generator/printers/java';
+
+import { javaOperationLiteral } from './descriptor.ts';
+import { hydration } from './models.ts';
+import { methodArgs, urlExpression, writeQueryParams } from './operations.ts';
+import { javaType } from './types.ts';
+
+/** `<op>Pages()` / `<op>Items()` iterables over the runtime's iterPages, hydrated per element. */
+export function writeJavaPaginationWrappers(
+  printer: JavaPrinter,
+  op: OperationModel,
+  ident: string,
+  model: ApiModel,
+  dateType: DateType,
+  rule: NeutralPaginationRule
+): void {
+  const args = methodArgs(op, ident, model, false, dateType);
+  const success = jsonSuccessSchema(op);
+  const pageType = success === undefined ? 'Object' : javaType(success, model, dateType);
+  const element = paginationItemSchema(success, rule.items, model);
+  const itemType = element === undefined ? 'Object' : javaType(element, model, dateType);
+  const pageHydration =
+    success === undefined ? 'page' : (hydration(success, 'page', model, dateType) ?? 'page');
+  const itemHydration =
+    element === undefined ? 'item' : (hydration(element, 'item', model, dateType, 1) ?? 'item');
+
+  const writeCall = () => {
+    printer.line(`Operation op = ${javaOperationLiteral(op, model, rule)};`);
+    printer.line('Map<String, List<String>> base = new LinkedHashMap<>();');
+    writeQueryParams(printer, args, 'base');
+    printer.block(
+      'PageCall call = pageParams -> {',
+      () => {
+        printer.line('ResolvedAuth auth = resolveAuth(op.security(), config.auth);');
+        printer.line('Map<String, List<String>> query = cloneQuery(auth.query());');
+        printer.line('query.putAll(pageParams);');
+        printer.line(`String url = ${urlExpression(args)};`);
+        printer.line(
+          'HttpResponse<InputStream> response = send(config, new RequestSpec(op.id(), op.method(), url).headers(auth.headers()).query(query));'
+        );
+        printer.block(
+          'if (response.statusCode() >= 400) {',
+          () => {
+            printer.line('throw apiErrorFrom(response, url);');
+          },
+          '}'
+        );
+        printer.line('return new PageResult(decodeJson(response), response);');
+      },
+      '};'
+    );
+  };
+
+  printer.line(`/** ${ident} response pages, following the pagination rule automatically. */`);
+  printer.block(
+    `public Iterable<${pageType}> ${ident}Pages(${args.signature.join(', ')}) {`,
+    () => {
+      writeCall();
+      printer.line(
+        `return mapIterable(iterPages(call, op.pagination(), base), page -> ${pageHydration});`
+      );
+    },
+    '}'
+  );
+  printer.blank();
+
+  printer.line(`/** The items of every ${ident} page. */`);
+  printer.block(
+    `public Iterable<${itemType}> ${ident}Items(${args.signature.join(', ')}) {`,
+    () => {
+      writeCall();
+      printer.line(
+        `return mapIterable(flattenItems(iterPages(call, op.pagination(), base), op.pagination().items()), item -> ${itemHydration});`
+      );
+    },
+    '}'
+  );
+  printer.blank();
+}

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

@@ -0,0 +1,103 @@
+// 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 `types` stage: the Java type for a schema, and what a named schema renders as.
+
+import {
+  type ApiModel,
+  type DateType,
+  deref,
+  discriminatorCases,
+  enumValues,
+  flattenAllOf,
+  type SchemaModel,
+  unwrapNullable,
+} from '@redocly/client-generator';
+
+import { typeName } from './naming.ts';
+
+/**
+ * What a named schema renders as: a record, a wire-backed enum, a sealed union interface
+ * (every mapping target is a record, so the interface can seal over them), or nothing.
+ */
+export function classify(name: string, model: ApiModel): 'record' | 'enum' | 'union' | 'other' {
+  const named = model.schemas.find((candidate) => candidate.name === name);
+  if (named === undefined) return 'other';
+  const schema = named.schema;
+  const asEnum = enumValues(schema);
+  if (asEnum !== undefined && (asEnum.scalar === 'string' || asEnum.scalar === 'integer')) {
+    return 'enum';
+  }
+  if (
+    (schema.kind === 'object' || schema.kind === 'intersection') &&
+    flattenAllOf(schema, model) !== undefined
+  ) {
+    return 'record';
+  }
+  const cases = discriminatorCases(schema, model);
+  if (
+    cases !== undefined &&
+    cases.cases.length > 0 &&
+    cases.cases.every((entry) => classify(entry.schemaName, model) === 'record')
+  ) {
+    return 'union';
+  }
+  return 'other';
+}
+
+const SCALARS = { string: 'String', integer: 'Long', number: 'Double', boolean: 'Boolean' };
+
+/** `date` or `date-time` — the two formats `dateType: Date` turns into java.time objects. */
+export function isDateFormat(schema: SchemaModel): boolean {
+  const format = schema.metadata?.format;
+  return format === 'date' || format === 'date-time';
+}
+
+/**
+ * The Java type for a schema. Every type is a reference type (`Long`, not `long`), so an
+ * optional or nullable value is simply `null`; untyped shapes widen to `Object`.
+ */
+export function javaType(
+  schema: SchemaModel,
+  model: ApiModel,
+  dateType: DateType = 'string'
+): string {
+  const bare = unwrapNullable(schema);
+  switch (bare.kind) {
+    case 'scalar':
+      if (dateType === 'Date' && bare.scalar === 'string') {
+        if (bare.metadata?.format === 'date-time') return 'OffsetDateTime';
+        if (bare.metadata?.format === 'date') return 'LocalDate';
+      }
+      return SCALARS[bare.scalar];
+    case 'array':
+      return `List<${javaType(bare.items, model, dateType)}>`;
+    case 'record':
+      return `Map<String, ${javaType(bare.value, model, dateType)}>`;
+    case 'ref': {
+      const kind = classify(bare.name, model);
+      if (kind !== 'other') return typeName(bare.name);
+      const target = deref(bare, model);
+      return target === undefined ? 'Object' : javaType(target, model, dateType);
+    }
+    case 'enum':
+      // Anonymous (inline) enums keep the wire scalar; only NAMED enums get types.
+      return SCALARS[bare.scalar];
+    case 'literal':
+      return typeof bare.value === 'string'
+        ? 'String'
+        : typeof bare.value === 'boolean'
+          ? 'Boolean'
+          : 'Double';
+    case 'omit':
+      // Java has no Omit; the base type is the honest annotation.
+      return javaType({ kind: 'ref', name: bare.base }, model, dateType);
+    case 'union':
+    case 'null':
+    case 'object':
+    case 'intersection':
+    case 'unknown':
+      return 'Object';
+  }
+}

package/lib/eject-assets/generators/mock/faker.ts

@@ -1,4 +1,4 @@
-// Ejected from @redocly/client-generator@0.7.12 — the built-in "mock" generator.
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "mock" 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 mock --update`.

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

@@ -1,4 +1,4 @@
-// Ejected from @redocly/client-generator@0.7.12 — the built-in "mock" generator.
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "mock" 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 mock --update`.
@@ -32,5 +32,5 @@ export default {
   name: 'mock',
   run: mockGenerator,
   requires: ["typescript"],
-  requiresGenerator: '^0.7.12',
+  requiresGenerator: '^0.8.0',
 };

package/lib/eject-assets/generators/mock/render.ts

@@ -1,4 +1,4 @@
-// Ejected from @redocly/client-generator@0.7.12 — the built-in "mock" generator.
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "mock" 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 mock --update`.

package/lib/eject-assets/generators/mock/sample.ts

@@ -1,4 +1,4 @@
-// Ejected from @redocly/client-generator@0.7.12 — the built-in "mock" generator.
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "mock" 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 mock --update`.

package/lib/eject-assets/generators/mock/values.ts

@@ -1,4 +1,4 @@
-// Ejected from @redocly/client-generator@0.7.12 — the built-in "mock" generator.
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "mock" 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 mock --update`.

package/lib/eject-assets/generators/php/client.ts

@@ -1,4 +1,4 @@
-// Ejected from @redocly/client-generator@0.7.12 — the built-in "php" generator.
+// Ejected from @redocly/client-generator@0.8.0 — the built-in "php" 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 php --update`.