@fern-api/fern-api-dev 5.50.2 → 5.50.3

package/cli.cjs

@@ -685536,7 +685536,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.50.2",
+          version: "5.50.3",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
@@ -685602,7 +685602,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.50.2",
+        version: "5.50.3",
         ...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.50.2";
+  const version7 = "5.50.3";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -897373,8 +897373,6 @@ async function buildAllTranslationInputs({ docsDefinition, git, apiDefinitions,
 
 // ../generation/remote-generation/remote-workspace-runner/lib/publishDocsLedgerPreview.js
 init_orpc_client();
-init_buildTranslatedDocsDefinition();
-var TRANSLATION_BUILD_CONCURRENCY2 = 4;
 async function publishDocsViaLedgerPreview({ docsDefinition, organization, basePath, previewId, git, token, fdrOrigin, headers: headers2, context: context3, apiDefinitions, fileManifest, filePaths, fileIdToPath, resolver: resolver2 }) {
   const { localeEntry: baseLocale, blobs } = buildLedgerInput({
     docsDefinition,
@@ -897383,28 +897381,21 @@ async function publishDocsViaLedgerPreview({ docsDefinition, organization, baseP
     fileManifest,
     fileIdToPath
   });
-  const builtTranslationDefs = await buildAllTranslationDefinitions({
+  const builtTranslations = await buildAllTranslationInputs({
     docsDefinition,
+    git,
+    apiDefinitions,
+    fileManifest,
+    fileIdToPath,
     resolver: resolver2,
     context: context3
   });
-  const translationInputs = builtTranslationDefs.map((t3) => {
-    const { localeEntry, blobs: translationBlobs } = buildLedgerInput({
-      docsDefinition: t3.translatedDefinition,
-      git,
-      apiDefinitions,
-      fileManifest,
-      fileIdToPath,
-      locale: t3.locale
-    });
-    return { ...t3, localeEntry, blobs: translationBlobs };
-  });
-  for (const t3 of translationInputs) {
+  for (const t3 of builtTranslations) {
     for (const [hash5, buf] of t3.blobs) {
       blobs.set(hash5, buf);
     }
   }
-  const locales = [baseLocale, ...translationInputs.map((t3) => t3.localeEntry)];
+  const locales = [baseLocale, ...builtTranslations.map((t3) => t3.localeEntry)];
   const client3 = createDocsLedgerClient2({ baseUrl: fdrOrigin, token, headers: headers2 });
   context3.logger.debug("[ledger-preview] Registering preview deployment...");
   const registerStart = performance.now();
@@ -897428,12 +897419,7 @@ async function publishDocsViaLedgerPreview({ docsDefinition, organization, baseP
     repo: baseLocale.repo,
     git
   };
-  const registerResult = await previewRegisterWithLocales({
-    fdrOrigin,
-    token,
-    headers: headers2,
-    input: previewRegisterInput
-  });
+  const registerResult = await client3.previewRegister(previewRegisterInput);
   const registerTime = performance.now() - registerStart;
   context3.logger.debug(`[ledger-preview] Registered in ${registerTime.toFixed(0)}ms \u2014 hash=${registerResult.deploymentHash}, preview=${registerResult.previewUrl}, missing=${registerResult.missingContent.length} blobs`);
   await uploadMissingBlobs(registerResult.missingContent, blobs, context3, filePaths);
@@ -897460,45 +897446,6 @@ async function publishDocsViaLedgerPreview({ docsDefinition, organization, baseP
     deploymentId: finishResult.deploymentId
   };
 }
-async function buildAllTranslationDefinitions({ docsDefinition, resolver: resolver2, context: context3 }) {
-  if (resolver2 == null) {
-    return [];
-  }
-  const translationPages = resolver2.getTranslationPages();
-  const translationNavigationOverlays = resolver2.getTranslationNavigationOverlays();
-  if (translationPages == null || Object.keys(translationPages).length === 0) {
-    return [];
-  }
-  const localeEntries = Object.entries(translationPages);
-  context3.logger.info(`[ledger-preview] Building ${localeEntries.length} translation locale(s)...`);
-  return asyncPool2(TRANSLATION_BUILD_CONCURRENCY2, localeEntries, async ([locale, localePages]) => {
-    const translatedDefinition = await buildTranslatedDocsDefinition({
-      docsDefinition,
-      locale,
-      localePages,
-      translationNavigationOverlays,
-      resolver: resolver2,
-      context: context3
-    });
-    return { locale, localePages, translatedDefinition };
-  });
-}
-async function previewRegisterWithLocales({ fdrOrigin, token, headers: headers2, input: input3 }) {
-  const response = await fetch(`${fdrOrigin.replace(/\/+$/, "")}/docs-ledger/preview/init`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
-      ...headers2
-    },
-    body: JSON.stringify(input3)
-  });
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`[ledger-preview] Preview register failed: HTTP ${response.status}: ${body}`);
-  }
-  return await response.json();
-}
 
 // ../generation/remote-generation/remote-workspace-runner/lib/retryWithBackoff.js
 async function retryWithBackoff({ fn: fn2, maxRetries, baseDelayMs, jitterFactor = 0, isRetryable = () => true, logger: logger4, label, delayFn = (ms2) => new Promise((resolve15) => setTimeout(resolve15, ms2)) }) {
@@ -898891,7 +898838,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.50.2",
+        cliVersion: "5.50.3",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -920485,6 +920432,7 @@ var DynamicSnippetsGeneratorContext = class _DynamicSnippetsGeneratorContext ext
 // ../../../generators/csharp/dynamic-snippets/lib/EndpointSnippetGenerator.js
 init_lib4();
 init_lodash();
+var REQUEST_PARAMETER_NAME = "request";
 var EndpointSnippetGenerator = class extends WithGeneration {
   context;
   constructor({ context: context3 }) {
@@ -920861,33 +920809,31 @@ var EndpointSnippetGenerator = class extends WithGeneration {
     }
   }
   getMethodArgsForInlinedRequest({ request: request7, snippet }) {
-    const args = [];
     this.context.errors.scope(Scope4.PathParameters);
-    const pathParameterFields = [];
     const pathParameters = [...this.context.ir.pathParameters ?? [], ...request7.pathParameters ?? []];
-    if (pathParameters.length > 0) {
-      pathParameterFields.push(...this.getPathParameters({ namedParameters: pathParameters, snippet }));
-    }
+    const includePathParameters = this.context.includePathParametersInWrappedRequest({
+      request: request7,
+      inlinePathParameters: this.settings.shouldInlinePathParameters
+    });
+    const pathParameterFields = includePathParameters ? this.getPathParameters({ namedParameters: pathParameters, snippet }) : [];
+    const separatePathParameterArgs = includePathParameters ? [] : this.getPathParameterArguments({ namedParameters: pathParameters, snippet });
     this.context.errors.unscope();
     this.context.errors.scope(Scope4.RequestBody);
     const filePropertyInfo = this.getFilePropertyInfo({ request: request7, snippet });
     this.context.errors.unscope();
-    if (!this.context.includePathParametersInWrappedRequest({
-      request: request7,
-      inlinePathParameters: this.settings.shouldInlinePathParameters
-    })) {
-      args.push(...pathParameterFields.map((field5) => field5.value));
-    }
-    args.push(this.getInlinedRequestArg({
+    const requestArg = this.getInlinedRequestArg({
       request: request7,
       snippet,
-      pathParameterFields: this.context.includePathParametersInWrappedRequest({
-        request: request7,
-        inlinePathParameters: this.settings.shouldInlinePathParameters
-      }) ? pathParameterFields : [],
+      pathParameterFields,
       filePropertyInfo
-    }));
-    return args;
+    });
+    if (separatePathParameterArgs.length > 0) {
+      return [
+        ...separatePathParameterArgs.map((arg) => this.namedArgument({ name: arg.name, value: arg.value })),
+        this.namedArgument({ name: REQUEST_PARAMETER_NAME, value: requestArg })
+      ];
+    }
+    return [requestArg];
   }
   getFilePropertyInfo({ request: request7, snippet }) {
     if (request7.body == null || !this.context.isFileUploadRequestBody(request7.body)) {
@@ -920999,20 +920945,44 @@ var EndpointSnippetGenerator = class extends WithGeneration {
     }
   }
   getMethodArgsForBodyRequest({ request: request7, snippet }) {
-    const args = [];
     this.context.errors.scope(Scope4.PathParameters);
     const pathParameters = [...this.context.ir.pathParameters ?? [], ...request7.pathParameters ?? []];
-    if (pathParameters.length > 0) {
-      args.push(...this.getPathParameters({ namedParameters: pathParameters, snippet }).map((field5) => field5.value));
-    }
+    const pathParameterArgs = this.getPathParameterArguments({ namedParameters: pathParameters, snippet });
     this.context.errors.unscope();
     this.context.errors.scope(Scope4.RequestBody);
-    if (request7.body != null) {
-      args.push(this.getBodyRequestArg({ body: request7.body, value: snippet.requestBody }));
-    }
+    const bodyArg = request7.body != null ? this.getBodyRequestArg({ body: request7.body, value: snippet.requestBody }) : void 0;
     this.context.errors.unscope();
+    if (pathParameterArgs.length > 0 && bodyArg != null) {
+      return [
+        ...pathParameterArgs.map((arg) => this.namedArgument({ name: arg.name, value: arg.value })),
+        this.namedArgument({ name: REQUEST_PARAMETER_NAME, value: bodyArg })
+      ];
+    }
+    const args = pathParameterArgs.map((arg) => arg.value);
+    if (bodyArg != null) {
+      args.push(bodyArg);
+    }
     return args;
   }
+  getPathParameterArguments({ namedParameters, snippet }) {
+    const pathParameters = this.context.associateByWireValueOrDefault({
+      parameters: namedParameters,
+      values: snippet.pathParameters ?? {}
+    });
+    return pathParameters.map((parameter6) => ({
+      name: this.context.getParameterName(parameter6.name.name),
+      value: this.context.dynamicLiteralMapper.convert({
+        ...parameter6,
+        fallbackToDefault: parameter6.name.wireValue
+      })
+    }));
+  }
+  namedArgument({ name: name2, value: value2 }) {
+    return this.csharp.codeblock((writer2) => {
+      writer2.write(`${name2}: `);
+      writer2.writeNode(value2);
+    });
+  }
   getBodyRequestArg({ body, value: value2 }) {
     switch (body.type) {
       case "bytes": {
@@ -924875,7 +924845,13 @@ 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(),
   "custom-pager-name": external_exports2.string().optional(),
   "offset-semantics": external_exports2.enum(["item-index", "page-index"]).optional(),
@@ -924994,19 +924970,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);
   }
 };
 
@@ -925619,7 +925599,7 @@ var TypeLiteral = class _TypeLiteral extends AstNode3 {
     writer2.write(".build()");
   }
   orderBuilderParameters(parameters2) {
-    const hasRequiredFields = parameters2.some((p6) => !p6.value.isOptional() && !this.isCollection(p6.value));
+    const hasRequiredFields = parameters2.some((p6) => this.isRequiredBuilderParameter(p6));
     if (!hasRequiredFields) {
       return parameters2.sort((a3, b5) => {
         const aIsOptional = a3.value.isOptional();
@@ -925634,8 +925614,8 @@ var TypeLiteral = class _TypeLiteral extends AstNode3 {
       });
     }
     return parameters2.sort((a3, b5) => {
-      const aIsNonRequired = this.isNonRequired(a3.value);
-      const bIsNonRequired = this.isNonRequired(b5.value);
+      const aIsNonRequired = !this.isRequiredBuilderParameter(a3);
+      const bIsNonRequired = !this.isRequiredBuilderParameter(b5);
       if (aIsNonRequired && !bIsNonRequired) {
         return 1;
       }
@@ -925649,6 +925629,12 @@ var TypeLiteral = class _TypeLiteral extends AstNode3 {
     const internalType = value2.internalType.type;
     return internalType === "list" || internalType === "set" || internalType === "map";
   }
+  isRequiredBuilderParameter(parameter6) {
+    if (parameter6.isRequired != null) {
+      return parameter6.isRequired;
+    }
+    return !this.isNonRequired(parameter6.value);
+  }
   isNonRequired(value2) {
     return value2.isOptional() || this.isCollection(value2);
   }
@@ -926159,7 +926145,10 @@ var DynamicTypeLiteralMapper = class {
     this.context = context3;
   }
   usesOptionalNullable() {
-    return this.context.customConfig?.["collapse-optional-nullable"] === true;
+    return this.context.usesOptionalNullable();
+  }
+  usesNullableAnnotation() {
+    return this.context.usesNullableAnnotation();
   }
   wrapInOptionalIfNotNop(value2, useOf = false, isCollapsedOptionalNullable = false) {
     if (java_exports.TypeLiteral.isNop(value2)) {
@@ -926170,6 +926159,22 @@ var DynamicTypeLiteralMapper = class {
     }
     return java_exports.TypeLiteral.optional({ value: value2, useOf });
   }
+  // Wraps an already-converted inner value for an `optional`/`nullable` wrapper type, honoring
+  // the `use-nullable-annotation` (raw, no wrapper) and `collapse-optional-nullable`
+  // (OptionalNullable<T>) configs. `propagatedCollapse` is set when an outer optional+nullable
+  // collapsed into this node.
+  wrapNullableOrOptionalValue({ value: value2, wrapperType, useOf, propagatedCollapse }) {
+    if (java_exports.TypeLiteral.isNop(value2)) {
+      return value2;
+    }
+    if (wrapperType === "nullable" && this.usesNullableAnnotation()) {
+      return value2;
+    }
+    if (propagatedCollapse || this.usesOptionalNullable() && wrapperType === "nullable") {
+      return this.context.getOptionalNullableOf(value2);
+    }
+    return java_exports.TypeLiteral.optional({ value: value2, useOf });
+  }
   convert(args) {
     if (args.value === null) {
       if (this.context.isNullable(args.typeReference)) {
@@ -926186,11 +926191,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) {
@@ -926200,16 +926215,20 @@ var DynamicTypeLiteralMapper = class {
           named,
           value: args.value,
           as: args.as,
-          inUndiscriminatedUnion: args.inUndiscriminatedUnion
+          inUndiscriminatedUnion: args.inUndiscriminatedUnion,
+          nestedClassReference: args.nestedClassReference
         });
       }
       case "nullable":
       case "optional": {
-        if (args.value === void 0 || typeof args.value === "object" && args.value !== null && Object.keys(args.value).length === 0 && args.typeReference.value.type === "named") {
-          const isCollapsed = args.isCollapsedOptionalNullable || this.usesOptionalNullable() && (args.typeReference.value.type === "optional" || args.typeReference.value.type === "nullable");
-          if (isCollapsed) {
-            return this.context.getOptionalNullableAbsent();
-          } else {
+        const wrapperType = args.typeReference.type;
+        const inner2 = args.typeReference.value;
+        if (args.value === void 0 || typeof args.value === "object" && args.value !== null && Object.keys(args.value).length === 0 && inner2.type === "named") {
+          if (!(wrapperType === "nullable" && this.usesNullableAnnotation())) {
+            const isCollapsed = args.isCollapsedOptionalNullable || this.usesOptionalNullable() && (wrapperType === "nullable" || inner2.type === "optional" || inner2.type === "nullable");
+            if (isCollapsed) {
+              return this.context.getOptionalNullableAbsent();
+            }
             return java_exports.TypeLiteral.reference(java_exports.invokeMethod({
               on: java_exports.classReference({
                 name: "Optional",
@@ -926220,39 +926239,60 @@ var DynamicTypeLiteralMapper = class {
             }));
           }
         }
-        if (args.typeReference.value.type === "list") {
-          const listLiteral = this.convertList({ list: args.typeReference.value.value, value: args.value });
-          return this.wrapInOptionalIfNotNop(listLiteral, true, args.isCollapsedOptionalNullable === true);
-        }
-        if (this.usesOptionalNullable() && (args.typeReference.value.type === "optional" || args.typeReference.value.type === "nullable")) {
+        if (this.usesOptionalNullable() && (inner2.type === "optional" || inner2.type === "nullable")) {
           return this.convert({
-            typeReference: args.typeReference.value,
+            typeReference: inner2,
             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,
+            nestedClassReference: args.nestedClassReference
+          });
+          return this.wrapNullableOrOptionalValue({
+            value: listLiteral,
+            wrapperType,
+            useOf: true,
+            propagatedCollapse: args.isCollapsedOptionalNullable === true
           });
         }
         const convertedValue = this.convert({
-          typeReference: args.typeReference.value,
+          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.wrapInOptionalIfNotNop(convertedValue, useOf, args.isCollapsedOptionalNullable === true);
+        return this.wrapNullableOrOptionalValue({
+          value: convertedValue,
+          wrapperType,
+          useOf,
+          propagatedCollapse: args.isCollapsedOptionalNullable === true
+        });
       }
       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,
@@ -926266,11 +926306,21 @@ var DynamicTypeLiteralMapper = class {
       values: value2.map((v3, index3) => {
         this.context.errors.scope({ index: index3 });
         try {
-          if (isItemOptional) {
-            const itemValue = this.convert({ typeReference: list29.value, value: v3, as: as2 });
-            return this.wrapInOptionalIfNotNop(itemValue, true);
+          if (isItemOptional && (list29.type === "optional" || list29.type === "nullable")) {
+            const itemValue = this.convert({
+              typeReference: list29.value,
+              value: v3,
+              as: as2,
+              nestedClassReference
+            });
+            return this.wrapNullableOrOptionalValue({
+              value: itemValue,
+              wrapperType: list29.type,
+              useOf: true,
+              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();
         }
@@ -926299,7 +926349,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,
@@ -926312,14 +926362,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,
@@ -926338,7 +926388,8 @@ var DynamicTypeLiteralMapper = class {
             value: this.convert({
               typeReference: map15.value,
               value: value3,
-              as: "mapValue"
+              as: "mapValue",
+              nestedClassReference
             })
           };
         } finally {
@@ -926347,7 +926398,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") {
@@ -926358,32 +926409,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({
@@ -926394,6 +926457,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({
@@ -926402,10 +926467,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": {
@@ -926416,6 +926495,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),
@@ -926423,7 +926509,8 @@ var DynamicTypeLiteralMapper = class {
               this.convert({
                 typeReference: unionVariant.typeReference,
                 value: record23[propertyKey],
-                as: as2
+                as: as2,
+                nestedClassReference: variantNestedClassReference
               })
             ]
           }));
@@ -926441,7 +926528,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,
@@ -926471,6 +926561,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);
@@ -926479,7 +926571,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) {
@@ -926489,7 +926588,8 @@ var DynamicTypeLiteralMapper = class {
         }
         builderParameters.push({
           name: this.context.getMethodName(property24.name.name),
-          value: convertedValue
+          value: convertedValue,
+          isRequired: this.isStagedBuilderProperty(property24.typeReference)
         });
       } finally {
         this.context.errors.unscope();
@@ -926501,18 +926601,178 @@ var DynamicTypeLiteralMapper = class {
         if (rawValue != null) {
           builderParameters.push({
             name: "additionalProperty",
-            value: java_exports.TypeLiteral.raw(`"${this.escapeJavaString(key2)}", ${rawValue}`)
+            value: java_exports.TypeLiteral.raw(`"${this.escapeJavaString(key2)}", ${rawValue}`),
+            isRequired: false
           });
         }
       }
     }
     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
+   * exposed on the final stage instead. This intentionally resolves aliases itself because the
+   * shared `isOptional` helper does not treat an alias to an optional type as optional.
+   */
+  isStagedBuilderProperty(typeReference2) {
+    switch (typeReference2.type) {
+      case "optional":
+      case "nullable":
+      case "list":
+      case "set":
+      case "map":
+        return false;
+      case "named": {
+        const resolvedType = this.context.resolveNamedType({ typeId: typeReference2.value });
+        if (resolvedType != null && resolvedType.type === "alias") {
+          return this.isStagedBuilderProperty(resolvedType.typeReference);
+        }
+        return true;
+      }
+      default:
+        return true;
+    }
+  }
   convertToRawJavaLiteral(value2) {
     if (typeof value2 === "string") {
       return `"${this.escapeJavaString(value2)}"`;
@@ -926605,13 +926865,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
@@ -926635,33 +926895,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 {
@@ -926669,7 +926924,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);
@@ -926991,9 +927252,27 @@ var DynamicTypeMapper3 = class {
         }
         return this.convertNamed({ named });
       }
-      case "optional":
+      case "optional": {
+        const inner2 = args.typeReference.value;
+        if (this.context.usesOptionalNullable() && (inner2.type === "nullable" || inner2.type === "optional")) {
+          return java_exports.Type.generic(this.context.getOptionalNullableClassReference(), [
+            this.convert({ typeReference: inner2.value })
+          ]);
+        }
+        return java_exports.Type.optional(this.convert({ typeReference: inner2 }));
+      }
       case "nullable": {
-        return java_exports.Type.optional(this.convert({ typeReference: args.typeReference.value }));
+        const inner2 = args.typeReference.value;
+        if (this.context.usesNullableAnnotation()) {
+          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: collapsed })
+          ]);
+        }
+        return java_exports.Type.optional(this.convert({ typeReference: inner2 }));
       }
       case "primitive":
         return this.convertPrimitive({ primitive: args.typeReference.value });
@@ -927170,22 +927449,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);
   }
@@ -927459,6 +927767,12 @@ var DynamicSnippetsGeneratorContext3 = class _DynamicSnippetsGeneratorContext ex
   shouldInlineFileProperties() {
     return this.customConfig?.["inline-file-properties"] ?? false;
   }
+  usesNullableAnnotation() {
+    return this.customConfig?.["use-nullable-annotation"] === true;
+  }
+  usesOptionalNullable() {
+    return this.customConfig?.["collapse-optional-nullable"] === true;
+  }
   getPackageNameSegments(fernFilepath) {
     return fernFilepath.packagePath.map((segment) => this.getPackageNameSegment(segment));
   }
@@ -928084,18 +928398,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]
     });
   }
@@ -928139,10 +928455,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":
@@ -928177,19 +928497,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
+        })
       })
     }));
   }
@@ -928224,8 +928553,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);
@@ -928250,15 +928579,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 }) {
@@ -950569,7 +950901,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
     });
@@ -950585,9 +950917,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: {
@@ -964576,7 +964910,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.50.2"
+    cli_version: "5.50.3"
   };
 }
 function isAutomationMode() {
@@ -965408,7 +965742,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.50.2";
+    return "5.50.3";
   }
   getCliName() {
     if (false) {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.50.2",
+  "version": "5.50.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",