@fern-api/fern-api-dev 5.23.3-832-gfa15174fbb2 → 5.23.3-839-gd570dc5b08c

package/cli.cjs

@@ -685536,7 +685536,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.23.3-832-gfa15174fbb2",
+          version: "5.23.3-839-gd570dc5b08c",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
@@ -685602,7 +685602,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.23.3-832-gfa15174fbb2",
+        version: "5.23.3-839-gd570dc5b08c",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -866664,7 +866664,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "5.23.3-832-gfa15174fbb2";
+  const version7 = "5.23.3-839-gd570dc5b08c";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -898891,7 +898891,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.23.3-832-gfa15174fbb2",
+        cliVersion: "5.23.3-839-gd570dc5b08c",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -924875,6 +924875,11 @@ var BaseJavaCustomConfigSchema = external_exports2.object({
   "enable-extensible-builders": external_exports2.boolean().optional(),
   "use-default-request-parameter-values": external_exports2.boolean().optional(),
   "enable-wire-tests": external_exports2.boolean().default(false),
+  // Nullable/optional representation options (mutually exclusive):
+  //   collapse-optional-nullable: optional<nullable<T>> (and standalone nullable<T>) collapses to
+  //     a single OptionalNullable<T> wrapper.
+  //   use-nullable-annotation: nullable<T> is emitted as the raw type T annotated with @Nullable
+  //     (no Optional wrapper). Mirrors v1 behaviour when the Java @Nullable annotation is preferred.
   "collapse-optional-nullable": external_exports2.boolean().optional(),
   "use-nullable-annotation": external_exports2.boolean().optional(),
   "custom-readme-sections": external_exports2.array(CustomReadmeSectionSchema).optional(),
@@ -924995,19 +925000,23 @@ var ClassReference2 = class extends AstNode3 {
   name;
   packageName;
   fullyQualified;
-  constructor({ name: name2, packageName, fullyQualified }) {
+  enclosingClasses;
+  constructor({ name: name2, packageName, fullyQualified, enclosingClasses }) {
     super();
     this.name = name2;
     this.packageName = packageName;
     this.fullyQualified = fullyQualified ?? false;
+    this.enclosingClasses = enclosingClasses ?? [];
   }
   write(writer2) {
-    writer2.addImport(`${this.packageName}.${this.name}`);
+    const topLevelClassName = this.enclosingClasses[0] ?? this.name;
+    const qualifiedName = [...this.enclosingClasses, this.name].join(".");
+    writer2.addImport(`${this.packageName}.${topLevelClassName}`);
     if (this.fullyQualified) {
-      writer2.write(`${this.packageName}.${this.name}`);
+      writer2.write(`${this.packageName}.${qualifiedName}`);
       return;
     }
-    writer2.write(this.name);
+    writer2.write(qualifiedName);
   }
 };
 
@@ -926212,11 +926221,21 @@ var DynamicTypeLiteralMapper = class {
     }
     switch (args.typeReference.type) {
       case "list":
-        return this.convertList({ list: args.typeReference.value, value: args.value, as: args.as });
+        return this.convertList({
+          list: args.typeReference.value,
+          value: args.value,
+          as: args.as,
+          nestedClassReference: args.nestedClassReference
+        });
       case "literal":
         return this.convertLiteral({ literal: args.typeReference.value, value: args.value });
       case "map":
-        return this.convertMap({ map: args.typeReference, value: args.value, as: args.as });
+        return this.convertMap({
+          map: args.typeReference,
+          value: args.value,
+          as: args.as,
+          nestedClassReference: args.nestedClassReference
+        });
       case "named": {
         const named = this.context.resolveNamedType({ typeId: args.typeReference.value });
         if (named == null) {
@@ -926226,7 +926245,8 @@ var DynamicTypeLiteralMapper = class {
           named,
           value: args.value,
           as: args.as,
-          inUndiscriminatedUnion: args.inUndiscriminatedUnion
+          inUndiscriminatedUnion: args.inUndiscriminatedUnion,
+          nestedClassReference: args.nestedClassReference
         });
       }
       case "nullable":
@@ -926255,11 +926275,16 @@ var DynamicTypeLiteralMapper = class {
             value: args.value,
             as: args.as,
             inUndiscriminatedUnion: args.inUndiscriminatedUnion,
-            isCollapsedOptionalNullable: true
+            isCollapsedOptionalNullable: true,
+            nestedClassReference: args.nestedClassReference
           });
         }
         if (inner2.type === "list") {
-          const listLiteral = this.convertList({ list: inner2.value, value: args.value });
+          const listLiteral = this.convertList({
+            list: inner2.value,
+            value: args.value,
+            nestedClassReference: args.nestedClassReference
+          });
           return this.wrapNullableOrOptionalValue({
             value: listLiteral,
             wrapperType,
@@ -926271,7 +926296,8 @@ var DynamicTypeLiteralMapper = class {
           typeReference: inner2,
           value: args.value,
           as: args.as,
-          inUndiscriminatedUnion: args.inUndiscriminatedUnion
+          inUndiscriminatedUnion: args.inUndiscriminatedUnion,
+          nestedClassReference: args.nestedClassReference
         });
         const useOf = args.as === "mapValue" || args.inUndiscriminatedUnion === true;
         return this.wrapNullableOrOptionalValue({
@@ -926284,14 +926310,19 @@ var DynamicTypeLiteralMapper = class {
       case "primitive":
         return this.convertPrimitive({ primitive: args.typeReference.value, value: args.value, as: args.as });
       case "set":
-        return this.convertSet({ set: args.typeReference.value, value: args.value, as: args.as });
+        return this.convertSet({
+          set: args.typeReference.value,
+          value: args.value,
+          as: args.as,
+          nestedClassReference: args.nestedClassReference
+        });
       case "unknown":
         return this.convertUnknown({ value: args.value });
       default:
         assertNever(args.typeReference);
     }
   }
-  convertList({ list: list29, value: value2, as: as2 }) {
+  convertList({ list: list29, value: value2, as: as2, nestedClassReference }) {
     if (!Array.isArray(value2)) {
       this.context.errors.add({
         severity: Severity.Critical,
@@ -926306,7 +926337,12 @@ var DynamicTypeLiteralMapper = class {
         this.context.errors.scope({ index: index3 });
         try {
           if (isItemOptional && (list29.type === "optional" || list29.type === "nullable")) {
-            const itemValue = this.convert({ typeReference: list29.value, value: v3, as: as2 });
+            const itemValue = this.convert({
+              typeReference: list29.value,
+              value: v3,
+              as: as2,
+              nestedClassReference
+            });
             return this.wrapNullableOrOptionalValue({
               value: itemValue,
               wrapperType: list29.type,
@@ -926314,7 +926350,7 @@ var DynamicTypeLiteralMapper = class {
               propagatedCollapse: false
             });
           }
-          return this.convert({ typeReference: list29, value: v3, as: as2 });
+          return this.convert({ typeReference: list29, value: v3, as: as2, nestedClassReference });
         } finally {
           this.context.errors.unscope();
         }
@@ -926343,7 +926379,7 @@ var DynamicTypeLiteralMapper = class {
         assertNever(literal3);
     }
   }
-  convertSet({ set: set26, value: value2, as: as2 }) {
+  convertSet({ set: set26, value: value2, as: as2, nestedClassReference }) {
     if (!Array.isArray(value2)) {
       this.context.errors.add({
         severity: Severity.Critical,
@@ -926356,14 +926392,14 @@ var DynamicTypeLiteralMapper = class {
       values: value2.map((v3, index3) => {
         this.context.errors.scope({ index: index3 });
         try {
-          return this.convert({ typeReference: set26, value: v3, as: as2 });
+          return this.convert({ typeReference: set26, value: v3, as: as2, nestedClassReference });
         } finally {
           this.context.errors.unscope();
         }
       })
     });
   }
-  convertMap({ map: map15, value: value2, as: as2 }) {
+  convertMap({ map: map15, value: value2, as: as2, nestedClassReference }) {
     if (typeof value2 !== "object" || value2 == null) {
       this.context.errors.add({
         severity: Severity.Critical,
@@ -926382,7 +926418,8 @@ var DynamicTypeLiteralMapper = class {
             value: this.convert({
               typeReference: map15.value,
               value: value3,
-              as: "mapValue"
+              as: "mapValue",
+              nestedClassReference
             })
           };
         } finally {
@@ -926391,7 +926428,7 @@ var DynamicTypeLiteralMapper = class {
       })
     });
   }
-  convertNamed({ named, value: value2, as: as2, inUndiscriminatedUnion }) {
+  convertNamed({ named, value: value2, as: as2, inUndiscriminatedUnion, nestedClassReference }) {
     switch (named.type) {
       case "alias":
         if (named.typeReference.type === "unknown") {
@@ -926402,32 +926439,44 @@ var DynamicTypeLiteralMapper = class {
             inUndiscriminatedUnion
           });
           return java_exports.TypeLiteral.reference(java_exports.invokeMethod({
-            on: this.context.getJavaClassReferenceFromDeclaration({
+            on: nestedClassReference ?? this.context.getJavaClassReferenceFromDeclaration({
               declaration: named.declaration
             }),
             method: "of",
             arguments_: [convertedValue]
           }));
         }
-        return this.convert({ typeReference: named.typeReference, value: value2, as: as2, inUndiscriminatedUnion });
+        return this.convert({
+          typeReference: named.typeReference,
+          value: value2,
+          as: as2,
+          inUndiscriminatedUnion,
+          nestedClassReference
+        });
       case "discriminatedUnion":
         return this.convertDiscriminatedUnion({
           discriminatedUnion: named,
           value: value2,
-          as: as2
+          as: as2,
+          nestedClassReference
         });
       case "enum":
-        return this.convertEnum({ enum_: named, value: value2 });
+        return this.convertEnum({ enum_: named, value: value2, nestedClassReference });
       case "object":
-        return this.convertObject({ object_: named, value: value2, as: as2, inUndiscriminatedUnion });
+        return this.convertObject({ object_: named, value: value2, as: as2, inUndiscriminatedUnion, nestedClassReference });
       case "undiscriminatedUnion":
-        return this.convertUndiscriminatedUnion({ undiscriminatedUnion: named, value: value2, as: as2 });
+        return this.convertUndiscriminatedUnion({
+          undiscriminatedUnion: named,
+          value: value2,
+          as: as2,
+          nestedClassReference
+        });
       default:
         assertNever(named);
     }
   }
-  convertDiscriminatedUnion({ discriminatedUnion: discriminatedUnion2, value: value2, as: as2 }) {
-    const classReference4 = this.context.getJavaClassReferenceFromDeclaration({
+  convertDiscriminatedUnion({ discriminatedUnion: discriminatedUnion2, value: value2, as: as2, nestedClassReference }) {
+    const classReference4 = nestedClassReference ?? this.context.getJavaClassReferenceFromDeclaration({
       declaration: discriminatedUnion2.declaration
     });
     const discriminatedUnionTypeInstance = this.context.resolveDiscriminatedUnionTypeInstance({
@@ -926438,6 +926487,8 @@ var DynamicTypeLiteralMapper = class {
       return java_exports.TypeLiteral.nop();
     }
     const unionVariant = discriminatedUnionTypeInstance.singleDiscriminatedUnionType;
+    const reservedNames = /* @__PURE__ */ new Set([...classReference4.enclosingClasses, classReference4.name]);
+    const siblingDiscriminantNames = new Set(Object.values(discriminatedUnion2.types).map((variant) => this.context.getClassName(variant.discriminantValue.name)));
     switch (unionVariant.type) {
       case "samePropertiesAsObject": {
         const named = this.context.resolveNamedType({
@@ -926446,10 +926497,24 @@ var DynamicTypeLiteralMapper = class {
         if (named == null) {
           return java_exports.TypeLiteral.nop();
         }
+        const variantNestedClassReference = this.resolveInlineNestedClassReference({
+          enclosing: classReference4,
+          baseName: this.context.getClassName(unionVariant.discriminantValue.name),
+          typeReference: { type: "named", value: unionVariant.typeId },
+          reservedNames,
+          siblingPropertyNames: siblingDiscriminantNames
+        });
         return java_exports.TypeLiteral.reference(java_exports.invokeMethod({
           on: classReference4,
           method: this.context.getPropertyName(unionVariant.discriminantValue.name),
-          arguments_: [this.convertNamed({ named, value: discriminatedUnionTypeInstance.value, as: as2 })]
+          arguments_: [
+            this.convertNamed({
+              named,
+              value: discriminatedUnionTypeInstance.value,
+              as: as2,
+              nestedClassReference: variantNestedClassReference
+            })
+          ]
         }));
       }
       case "singleProperty": {
@@ -926460,6 +926525,13 @@ var DynamicTypeLiteralMapper = class {
         try {
           this.context.errors.scope(unionVariant.discriminantValue.wireValue);
           const propertyKey = "value";
+          const variantNestedClassReference = this.resolveInlineNestedClassReference({
+            enclosing: classReference4,
+            baseName: this.context.getClassName(unionVariant.discriminantValue.name),
+            typeReference: unionVariant.typeReference,
+            reservedNames,
+            siblingPropertyNames: siblingDiscriminantNames
+          });
           return java_exports.TypeLiteral.reference(java_exports.invokeMethod({
             on: classReference4,
             method: this.context.getPropertyName(unionVariant.discriminantValue.name),
@@ -926467,7 +926539,8 @@ var DynamicTypeLiteralMapper = class {
               this.convert({
                 typeReference: unionVariant.typeReference,
                 value: record23[propertyKey],
-                as: as2
+                as: as2,
+                nestedClassReference: variantNestedClassReference
               })
             ]
           }));
@@ -926485,7 +926558,10 @@ var DynamicTypeLiteralMapper = class {
         assertNever(unionVariant);
     }
   }
-  convertObject({ object_, value: value2, as: as2, inUndiscriminatedUnion }) {
+  convertObject({ object_, value: value2, as: as2, inUndiscriminatedUnion, nestedClassReference }) {
+    const classReference4 = nestedClassReference ?? this.context.getJavaClassReferenceFromDeclaration({
+      declaration: object_.declaration
+    });
     const valueRecord = this.context.getRecord(value2) ?? {};
     const properties7 = this.context.associateByWireValue({
       parameters: object_.properties,
@@ -926515,6 +926591,8 @@ var DynamicTypeLiteralMapper = class {
     });
     properties7.sort((a3, b5) => (paramOrderMap.get(a3.name.wireValue) ?? 0) - (paramOrderMap.get(b5.name.wireValue) ?? 0));
     const filteredProperties = as2 === "request" ? properties7.filter((property24) => !this.context.isDirectLiteral(property24.typeReference)) : properties7;
+    const reservedNames = /* @__PURE__ */ new Set([...classReference4.enclosingClasses, classReference4.name]);
+    const siblingPropertyNames = new Set(object_.properties.map((property24) => this.context.getClassName(property24.name.name)));
     const builderParameters = [];
     for (const property24 of filteredProperties) {
       this.context.errors.scope(property24.name.wireValue);
@@ -926523,7 +926601,14 @@ var DynamicTypeLiteralMapper = class {
           typeReference: property24.typeReference,
           value: property24.value,
           as: as2,
-          inUndiscriminatedUnion
+          inUndiscriminatedUnion,
+          nestedClassReference: this.resolveInlineNestedClassReference({
+            enclosing: classReference4,
+            baseName: this.context.getClassName(property24.name.name),
+            typeReference: property24.typeReference,
+            reservedNames,
+            siblingPropertyNames
+          })
         });
         if (java_exports.TypeLiteral.isNop(convertedValue) && !this.context.isOptional(property24.typeReference)) {
           if (inUndiscriminatedUnion === true) {
@@ -926553,12 +926638,146 @@ var DynamicTypeLiteralMapper = class {
       }
     }
     return java_exports.TypeLiteral.builder({
-      classReference: this.context.getJavaClassReferenceFromDeclaration({
-        declaration: object_.declaration
-      }),
+      classReference: classReference4,
       parameters: builderParameters
     });
   }
+  /**
+   * Mirrors the v1 generator's inline-type naming (see ObjectGenerator / InlineTypeIdResolver):
+   * when a property's type resolves to an inline named type, v1 emits it as a class nested within
+   * the enclosing object. This walks the property's type reference (descending through container
+   * wrappers, applying the same name suffixes as v1) and, if it terminates in an inline named type,
+   * returns the nested class reference to use. Returns undefined for non-inline types, which fall
+   * back to the standalone top-level class name.
+   */
+  resolveInlineNestedClassReference({ enclosing, baseName, typeReference: typeReference2, reservedNames, siblingPropertyNames }) {
+    if (!this.context.enableInlineTypes()) {
+      return void 0;
+    }
+    switch (typeReference2.type) {
+      case "optional":
+      case "nullable":
+        return this.resolveInlineNestedClassReference({
+          enclosing,
+          baseName,
+          typeReference: typeReference2.value,
+          reservedNames,
+          siblingPropertyNames
+        });
+      case "list":
+      case "set":
+        return this.resolveInlineNestedClassReference({
+          enclosing,
+          baseName: `${baseName}Item`,
+          typeReference: typeReference2.value,
+          reservedNames,
+          siblingPropertyNames
+        });
+      case "map":
+        return this.resolveInlineNestedClassReference({
+          enclosing,
+          baseName: `${baseName}Value`,
+          typeReference: typeReference2.value,
+          reservedNames,
+          siblingPropertyNames
+        });
+      case "named": {
+        const typeId = typeReference2.value;
+        const named = this.context.resolveNamedType({ typeId });
+        if (named == null) {
+          return void 0;
+        }
+        if (named.type === "alias" && !this.context.wrappedAliases()) {
+          return this.resolveInlineNestedClassReference({
+            enclosing,
+            baseName,
+            typeReference: named.typeReference,
+            reservedNames,
+            siblingPropertyNames
+          });
+        }
+        if (!this.context.isInlineType(typeId)) {
+          return void 0;
+        }
+        let name2 = baseName;
+        while (reservedNames.has(name2) || siblingPropertyNames.has(name2) && name2 !== baseName) {
+          name2 = `${name2}_`;
+        }
+        reservedNames.add(name2);
+        return this.context.getNestedInlineClassReference({ enclosing, name: name2 });
+      }
+      case "primitive":
+      case "literal":
+      case "unknown":
+        return void 0;
+      default:
+        assertNever(typeReference2);
+    }
+  }
+  /**
+   * Resolves the nested class reference for an inline member of an undiscriminated union.
+   * Unlike object properties and discriminated-union variants (whose nested name is derived
+   * from the property/discriminant name), v1 names an undiscriminated union's inline members
+   * after the member type's own name, with the union's name stripped as a prefix (see
+   * UndiscriminatedUnionGenerator). Descends through container wrappers to the terminal named
+   * type.
+   */
+  resolveUndiscriminatedInlineNestedClassReference({ enclosing, typeReference: typeReference2, reservedNames, unionPrefix }) {
+    if (!this.context.enableInlineTypes()) {
+      return void 0;
+    }
+    switch (typeReference2.type) {
+      case "optional":
+      case "nullable":
+      case "list":
+      case "set":
+        return this.resolveUndiscriminatedInlineNestedClassReference({
+          enclosing,
+          typeReference: typeReference2.value,
+          reservedNames,
+          unionPrefix
+        });
+      case "map":
+        return this.resolveUndiscriminatedInlineNestedClassReference({
+          enclosing,
+          typeReference: typeReference2.value,
+          reservedNames,
+          unionPrefix
+        });
+      case "named": {
+        const typeId = typeReference2.value;
+        const named = this.context.resolveNamedType({ typeId });
+        if (named == null) {
+          return void 0;
+        }
+        if (named.type === "alias" && !this.context.wrappedAliases()) {
+          return this.resolveUndiscriminatedInlineNestedClassReference({
+            enclosing,
+            typeReference: named.typeReference,
+            reservedNames,
+            unionPrefix
+          });
+        }
+        if (!this.context.isInlineType(typeId)) {
+          return void 0;
+        }
+        let name2 = this.context.getClassName(named.declaration.name);
+        if (name2.startsWith(unionPrefix) && name2 !== unionPrefix) {
+          name2 = name2.substring(unionPrefix.length);
+        }
+        while (reservedNames.has(name2)) {
+          name2 = `${name2}_`;
+        }
+        return this.context.getNestedInlineClassReference({ enclosing, name: name2 });
+      }
+      case "primitive":
+      case "literal":
+      case "unknown":
+        return void 0;
+      default:
+        assertNever(typeReference2);
+    }
+  }
   /**
    * Returns true when a property becomes a required stage in v1's staged builder. v1 stages
    * fields that are neither optional, nullable, nor collections (list/set/map); those are all
@@ -926676,13 +926895,13 @@ var DynamicTypeLiteralMapper = class {
         return "string";
     }
   }
-  convertEnum({ enum_: enum_25, value: value2 }) {
+  convertEnum({ enum_: enum_25, value: value2, nestedClassReference }) {
     const name2 = this.getEnumValueName({ enum_: enum_25, value: value2 });
     if (name2 == null) {
       return java_exports.TypeLiteral.nop();
     }
     return java_exports.TypeLiteral.enum_({
-      classReference: this.context.getJavaClassReferenceFromDeclaration({
+      classReference: nestedClassReference ?? this.context.getJavaClassReferenceFromDeclaration({
         declaration: enum_25.declaration
       }),
       value: name2
@@ -926706,33 +926925,28 @@ var DynamicTypeLiteralMapper = class {
     }
     return this.context.getEnumName(enumValue.name);
   }
-  convertUndiscriminatedUnion({ undiscriminatedUnion: undiscriminatedUnion22, value: value2, as: as2 }) {
+  convertUndiscriminatedUnion({ undiscriminatedUnion: undiscriminatedUnion22, value: value2, as: as2, nestedClassReference }) {
+    const classReference4 = nestedClassReference ?? this.context.getJavaClassReferenceFromDeclaration({
+      declaration: undiscriminatedUnion22.declaration
+    });
     const result = this.findMatchingUndiscriminatedUnionType({
       undiscriminatedUnion: undiscriminatedUnion22,
       value: value2,
-      as: as2
+      as: as2,
+      enclosing: classReference4
     });
     if (result == null) {
       return java_exports.TypeLiteral.nop();
     }
-    if (this.context.isPrimitive(result.valueTypeReference)) {
-      return java_exports.TypeLiteral.reference(java_exports.invokeMethod({
-        on: this.context.getJavaClassReferenceFromDeclaration({
-          declaration: undiscriminatedUnion22.declaration
-        }),
-        method: "of",
-        arguments_: [result.typeInstantiation]
-      }));
-    }
     return java_exports.TypeLiteral.reference(java_exports.invokeMethod({
-      on: this.context.getJavaClassReferenceFromDeclaration({
-        declaration: undiscriminatedUnion22.declaration
-      }),
+      on: classReference4,
       method: "of",
       arguments_: [result.typeInstantiation]
     }));
   }
-  findMatchingUndiscriminatedUnionType({ undiscriminatedUnion: undiscriminatedUnion22, value: value2, as: as2 }) {
+  findMatchingUndiscriminatedUnionType({ undiscriminatedUnion: undiscriminatedUnion22, value: value2, as: as2, enclosing }) {
+    const reservedNames = /* @__PURE__ */ new Set([...enclosing.enclosingClasses, enclosing.name]);
+    const unionPrefix = this.context.getClassName(undiscriminatedUnion22.declaration.name);
     for (const typeReference2 of undiscriminatedUnion22.types) {
       const errorsBefore = this.context.errors.size();
       try {
@@ -926740,7 +926954,13 @@ var DynamicTypeLiteralMapper = class {
           typeReference: typeReference2,
           value: value2,
           as: as2,
-          inUndiscriminatedUnion: true
+          inUndiscriminatedUnion: true,
+          nestedClassReference: this.resolveUndiscriminatedInlineNestedClassReference({
+            enclosing,
+            typeReference: typeReference2,
+            reservedNames: new Set(reservedNames),
+            unionPrefix
+          })
         });
         if (java_exports.TypeLiteral.isNop(typeInstantiation) || this.context.errors.size() > errorsBefore) {
           this.context.errors.truncate(errorsBefore);
@@ -927064,7 +927284,7 @@ var DynamicTypeMapper3 = class {
       }
       case "optional": {
         const inner2 = args.typeReference.value;
-        if (this.context.usesOptionalNullable() && inner2.type === "nullable") {
+        if (this.context.usesOptionalNullable() && (inner2.type === "nullable" || inner2.type === "optional")) {
           return java_exports.Type.generic(this.context.getOptionalNullableClassReference(), [
             this.convert({ typeReference: inner2.value })
           ]);
@@ -927077,8 +927297,9 @@ var DynamicTypeMapper3 = class {
           return this.convert({ typeReference: inner2 });
         }
         if (this.context.usesOptionalNullable()) {
+          const collapsed = inner2.type === "optional" || inner2.type === "nullable" ? inner2.value : inner2;
           return java_exports.Type.generic(this.context.getOptionalNullableClassReference(), [
-            this.convert({ typeReference: inner2 })
+            this.convert({ typeReference: collapsed })
           ]);
         }
         return java_exports.Type.optional(this.convert({ typeReference: inner2 }));
@@ -927258,22 +927479,51 @@ var DynamicSnippetsGeneratorContext3 = class _DynamicSnippetsGeneratorContext ex
   dynamicTypeMapper;
   dynamicTypeLiteralMapper;
   filePropertyMapper;
-  constructor({ ir: ir3, config: config5, options: options2, sharedCustomConfig }) {
+  /**
+   * The set of type IDs that the v1 generator emits as nested (inline) classes rather than
+   * top-level types. The dynamic IR does not carry the `inline` flag, so the v2 SDK generator
+   * computes this from the full IR and threads it through. Used to mirror v1's nested-class
+   * naming when referencing inline types in snippets.
+   */
+  inlineTypeIds;
+  constructor({ ir: ir3, config: config5, options: options2, sharedCustomConfig, inlineTypeIds }) {
     super({ ir: ir3, config: config5, options: options2 });
     this.ir = ir3;
     this.customConfig = sharedCustomConfig ?? BaseJavaCustomConfigSchema.parse(config5.customConfig ?? {});
     this.dynamicTypeMapper = new DynamicTypeMapper3({ context: this });
     this.dynamicTypeLiteralMapper = new DynamicTypeLiteralMapper({ context: this });
     this.filePropertyMapper = new FilePropertyMapper3({ context: this });
+    this.inlineTypeIds = inlineTypeIds ?? /* @__PURE__ */ new Set();
   }
   clone() {
     return new _DynamicSnippetsGeneratorContext({
       ir: this.ir,
       config: this.config,
       options: this.options,
-      sharedCustomConfig: this.customConfig
+      sharedCustomConfig: this.customConfig,
+      inlineTypeIds: this.inlineTypeIds
     });
   }
+  isInlineType(typeId) {
+    return this.inlineTypeIds.has(typeId);
+  }
+  /**
+   * Builds a reference to a class nested within `enclosing`. The resulting reference imports the
+   * outermost enclosing class and is written using the dotted path (e.g. `PostRootRequest.Bar`).
+   */
+  getNestedInlineClassReference({ enclosing, name: name2 }) {
+    return java_exports.classReference({
+      name: name2,
+      packageName: enclosing.packageName,
+      enclosingClasses: [...enclosing.enclosingClasses, enclosing.name]
+    });
+  }
+  wrappedAliases() {
+    return this.customConfig?.["wrapped-aliases"] ?? false;
+  }
+  enableInlineTypes() {
+    return this.customConfig?.["enable-inline-types"] ?? false;
+  }
   getClassName(name2) {
     return this.getName(name2.pascalCase.safeName);
   }
@@ -928178,18 +928428,20 @@ var EndpointSnippetGenerator3 = class {
       })
     }));
     this.context.errors.unscope();
+    const requestClassReference = java_exports.classReference({
+      name: this.context.getClassName(request7.declaration.name),
+      packageName: this.context.getRequestsPackageName(request7.declaration.fernFilepath)
+    });
     this.context.errors.scope(Scope4.RequestBody);
     const requestBodyFields = request7.body != null ? this.getInlinedRequestBodyBuilderParameters({
       body: request7.body,
       value: snippet.requestBody,
-      filePropertyInfo
+      filePropertyInfo,
+      enclosing: requestClassReference
     }) : [];
     this.context.errors.unscope();
     return java_exports.TypeLiteral.builder({
-      classReference: java_exports.classReference({
-        name: this.context.getClassName(request7.declaration.name),
-        packageName: this.context.getRequestsPackageName(request7.declaration.fernFilepath)
-      }),
+      classReference: requestClassReference,
       parameters: [...pathParameterFields, ...headerFields, ...queryParameterFields, ...requestBodyFields]
     });
   }
@@ -928233,10 +928485,14 @@ var EndpointSnippetGenerator3 = class {
     });
     return java_exports.TypeLiteral.reference(buildMethodCall);
   }
-  getInlinedRequestBodyBuilderParameters({ body, value: value2, filePropertyInfo }) {
+  getInlinedRequestBodyBuilderParameters({ body, value: value2, filePropertyInfo, enclosing }) {
     switch (body.type) {
       case "properties":
-        return this.getInlinedRequestBodyPropertyBuilderParameters({ parameters: body.value, value: value2 });
+        return this.getInlinedRequestBodyPropertyBuilderParameters({
+          parameters: body.value,
+          value: value2,
+          enclosing
+        });
       case "referenced":
         return [this.getReferencedRequestBodyPropertyBuilderParameter({ body, value: value2 })];
       case "fileUpload":
@@ -928271,19 +928527,28 @@ var EndpointSnippetGenerator3 = class {
         assertNever(body);
     }
   }
-  getInlinedRequestBodyPropertyBuilderParameters({ parameters: parameters2, value: value2 }) {
+  getInlinedRequestBodyPropertyBuilderParameters({ parameters: parameters2, value: value2, enclosing }) {
     const bodyProperties = this.context.associateByWireValue({
       parameters: parameters2,
       values: this.context.getRecord(value2) ?? {}
     });
     const filteredProperties = bodyProperties.filter((parameter6) => !this.context.isDirectLiteral(parameter6.typeReference));
     const sortedProperties = this.context.sortTypeInstancesByRequiredFirst(filteredProperties, parameters2);
+    const reservedNames = /* @__PURE__ */ new Set([...enclosing.enclosingClasses, enclosing.name]);
+    const siblingPropertyNames = new Set(parameters2.map((parameter6) => this.context.getClassName(parameter6.name.name)));
     return sortedProperties.map((parameter6) => ({
       name: this.context.getMethodName(parameter6.name.name),
       value: this.context.dynamicTypeLiteralMapper.convert({
         typeReference: parameter6.typeReference,
         value: parameter6.value,
-        as: "request"
+        as: "request",
+        nestedClassReference: this.context.dynamicTypeLiteralMapper.resolveInlineNestedClassReference({
+          enclosing,
+          baseName: this.context.getClassName(parameter6.name.name),
+          typeReference: parameter6.typeReference,
+          reservedNames,
+          siblingPropertyNames
+        })
       })
     }));
   }
@@ -928318,8 +928583,8 @@ var EndpointSnippetGenerator3 = class {
 
 // ../../../generators/java-v2/dynamic-snippets/lib/DynamicSnippetsGenerator.js
 var DynamicSnippetsGenerator3 = class extends AbstractDynamicSnippetsGenerator {
-  constructor({ ir: ir3, config: config5, options: options2 = {} }) {
-    super(new DynamicSnippetsGeneratorContext3({ ir: ir3, config: config5, options: options2 }));
+  constructor({ ir: ir3, config: config5, options: options2 = {}, inlineTypeIds }) {
+    super(new DynamicSnippetsGeneratorContext3({ ir: ir3, config: config5, options: options2, inlineTypeIds }));
   }
   async generate(request7, options2 = {}) {
     return super.generate(request7, options2);
@@ -928344,15 +928609,18 @@ var DynamicSnippetsJavaTestGenerator = class {
   context;
   ir;
   generatorConfig;
+  inlineTypeIds;
   dynamicSnippetsGenerator;
-  constructor(context3, ir3, generatorConfig) {
+  constructor(context3, ir3, generatorConfig, inlineTypeIds) {
     this.context = context3;
     this.ir = ir3;
     this.generatorConfig = generatorConfig;
+    this.inlineTypeIds = inlineTypeIds;
     this.dynamicSnippetsGenerator = new DynamicSnippetsGenerator3({
       // biome-ignore lint/suspicious/noExplicitAny: workaround for version incompatibility - see note above
       ir: convertIr(this.ir),
-      config: this.generatorConfig
+      config: this.generatorConfig,
+      inlineTypeIds: this.inlineTypeIds
     });
   }
   async generateTests({ outputDir, requests: requests3 }) {
@@ -950663,7 +950931,7 @@ var DynamicSnippetsTestGenerator = class _DynamicSnippetsTestGenerator {
       this.context.logger.debug(`Skipping dynamic snippets test generation for language "${language}"`);
       return;
     }
-    return new config5.generator(this.context, this.testSuite.ir, this.testSuite.config).generateTests({
+    return new config5.generator(this.context, this.testSuite.ir, this.testSuite.config, this.testSuite.inlineTypeIds).generateTests({
       outputDir,
       requests: this.testSuite.requests
     });
@@ -950679,9 +950947,11 @@ async function generateDynamicSnippetsTestSuite({ ir: ir3, config: config5 }) {
       code: CliError.Code.InternalError
     });
   }
+  const inlineTypeIds = new Set(Object.values(ir3.types).filter((typeDeclaration2) => typeDeclaration2.inline === true).map((typeDeclaration2) => typeDeclaration2.name.typeId));
   return {
     ir: ir3.dynamic,
     config: config5,
+    inlineTypeIds,
     requests: Object.entries(ir3.dynamic.endpoints).flatMap(([endpointId, endpoint3]) => (endpoint3.examples ?? []).map((example) => ({
       endpointId,
       request: {
@@ -964670,7 +964940,7 @@ function getAutomationContextFromEnv() {
     config_branch: process.env.FERN_CONFIG_BRANCH,
     config_pr_number: process.env.FERN_CONFIG_PR_NUMBER,
     trigger: process.env.GITHUB_EVENT_NAME,
-    cli_version: "5.23.3-832-gfa15174fbb2"
+    cli_version: "5.23.3-839-gd570dc5b08c"
   };
 }
 function isAutomationMode() {
@@ -965502,7 +965772,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.23.3-832-gfa15174fbb2";
+    return "5.23.3-839-gd570dc5b08c";
   }
   getCliName() {
     if (false) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.23.3-832-gfa15174fbb2",
+  "version": "5.23.3-839-gd570dc5b08c",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",